{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook for Training ResNet on The TinyImageNet dataset. Notebook (2/4) in the End-to-End Scalable Deep Learning Pipeline on Hops.\n",
    "\n",
    "ResNet is one of the state-of-the-art deep networks for computer vision. ResNet is based on the idea of residual learning. A residual network has so called \"shortcut connections\" parallel to the normal convolutional layers. Those shortcuts act like highways for gradients which allows to train extremely deep networks without suffering from vanishing or exploding gradients. Intuitively, by having the short-cut connections available during training, the network can learn which layers it doesn't need, since it can always fall-back on the shortcut (identity) connection.\n",
    "![resnet1.png](../images/resnet_1.png)\n",
    "\n",
    "Despite the huge increase in the overall depth, a ResNet with 50 layers has roughly half the parameters in AlexNet, this is because ResNet relies only on small filters in the network. E.g a stack of several 3x3 filters uses the same number of parameters as a single 7x7 filter. \n",
    "\n",
    "ResNet come in different depths: Resnet18, Resnet34, Resnet50,Resnet101, Resnet152\n",
    "\n",
    "For the deeper variants, ResNet uses \"bottleneck building blocks\" to lower the training time for the deepest networks. \n",
    "\n",
    "![bottlenneck.png](../images/bottleneck.png)\n",
    "\n",
    "ResNet uses batch notmalization right after each convolution and before the activation function. Typically ReLU is used as the activation function.\n",
    "\n",
    "\n",
    "This notebook will read the TFRecords that were written by notebook number 1 ([Notebook number one](./Step1_Save_to_Featurestore.ipynb)) and feed them into ResNet for single-GPU training and distributed hyperparameter search using several GPUs. \n",
    "\n",
    "Specifically, this notebook reads TFRecords dataset called 'train_dataset_tinyimagenet' from the featurestore.\n",
    "\n",
    "![step2.png](../images/step2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Package Imports\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.applications import ResNet50\n",
    "from hops import experiment, tensorboard, featurestore, hdfs\n",
    "from tensorflow import keras\n",
    "from tensorflow.python.keras.callbacks import TensorBoard\n",
    "import numpy as np\n",
    "import math\n",
    "import json\n",
    "from tensorflow.keras import metrics\n",
    "from tensorflow.keras.models import load_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "HEIGHT = 64\n",
    "WIDTH = 64\n",
    "CHANNELS = 3\n",
    "BATCH_SIZE = 100\n",
    "SHUFFLE_BUFFER_SIZE = 1000\n",
    "INPUT_SHAPE = 12288\n",
    "NUM_CLASSES = 200\n",
    "NUM_EPOCHS = 5\n",
    "LEARNING_RATE = 0.001\n",
    "TRAIN_DATASET = \"train_dataset_tinyimagenet\"\n",
    "TEST_DATASET = \"test_dataset_tinyimagenet\"\n",
    "VAL_DATASET = \"val_dataset_tinyimagenet\"\n",
    "MODEL_NAME = \"tinyimagenet_resnet50.h5\"\n",
    "HYPERPARAMS_FILE = \"tinyimagenet_best_hyperparams.json\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAIN_DATASET_SIZE = featurestore.get_training_dataset(TRAIN_DATASET).count()\n",
    "STEPS_PER_EPOCH = int(math.floor(float(TRAIN_DATASET_SIZE)/float(BATCH_SIZE)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%local\n",
    "HYPERPARAMS_FILE = \"tinyimagenet_best_hyperparams.json\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def define_model():\n",
    "    \"\"\"\n",
    "    Defines the model to use for image classification. \n",
    "    \n",
    "    Uses a pre-defined ResNet50 implementation provided by Keras, but uses randomly initialized weights,\n",
    "    i.e pre-defined but not pre-TRAINED.\n",
    "    \n",
    "    Returns:\n",
    "           ResNet50 model\n",
    "    \"\"\"\n",
    "    model = ResNet50(weights=None, input_shape=(HEIGHT, WIDTH, CHANNELS), classes=NUM_CLASSES)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Model Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_tf_dataset(dataset_name, shuffle_buffer_size, batch_size, num_epochs):\n",
    "    \"\"\"\n",
    "    Creates a Tensorflow Dataset from TFRecords on HopsFS stored in the feature store.\n",
    "    \n",
    "    Args:\n",
    "        :dataset_name: name of the training dataset in the featurestore (TFRecords format)\n",
    "        :shuffle_buffer_size: size of the shuffle buffer in memory for shuffling the dataset\n",
    "        :batch_size: the size of the batch\n",
    "        :num_epochs: number of epochs to repeat the dataset\n",
    "    \n",
    "    Returns:\n",
    "           Tensorflow dataset\n",
    "    \"\"\"\n",
    "    \n",
    "    # Get Path and Schema from feature store metadata\n",
    "    tf_record_schema = featurestore.get_training_dataset_tf_record_schema(dataset_name)\n",
    "    dataset_dir = featurestore.get_training_dataset_path(dataset_name)\n",
    "    \n",
    "    input_files = tf.gfile.Glob(dataset_dir + \"/part-r-*\")\n",
    "    dataset = tf.data.TFRecordDataset(input_files)\n",
    "\n",
    "    def decode(example_proto):\n",
    "        example = tf.parse_single_example(example_proto, tf_record_schema)\n",
    "        label_int = example[\"label\"]\n",
    "        image_flat = example[\"image\"]\n",
    "        image = tf.reshape(image_flat, (HEIGHT,WIDTH,CHANNELS))\n",
    "        label = tf.one_hot(label_int, NUM_CLASSES)\n",
    "        return image, label\n",
    "\n",
    "    dataset = dataset.map(decode).batch(batch_size).shuffle(shuffle_buffer_size)\n",
    "    dataset = dataset.repeat(num_epochs)\n",
    "    # prefetch 1 batch to make bottleneck on GPU bandwidth less likely\n",
    "    dataset = dataset.prefetch(1)\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_read_dataset():\n",
    "    \"\"\"\n",
    "    Utility function for confirming that parsing the tfrecord files is working correctly\n",
    "    \"\"\"\n",
    "    with tf.Session() as sess:\n",
    "        dataset = create_tf_dataset(TRAIN_DATASET, SHUFFLE_BUFFER_SIZE, BATCH_SIZE, NUM_EPOCHS)\n",
    "        dataset_iter = dataset.make_one_shot_iterator()\n",
    "        for i in range(5):\n",
    "            x,y = sess.run(dataset_iter.get_next())\n",
    "            print(\"feature batch shape: {}, label batch shape: {}\".format(x.shape, y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feature batch shape: (100, 64, 64, 3), label batch shape: (100, 200)\n",
      "feature batch shape: (100, 64, 64, 3), label batch shape: (100, 200)\n",
      "feature batch shape: (100, 64, 64, 3), label batch shape: (100, 200)\n",
      "feature batch shape: (100, 64, 64, 3), label batch shape: (100, 200)\n",
      "feature batch shape: (100, 64, 64, 3), label batch shape: (100, 200)"
     ]
    }
   ],
   "source": [
    "test_read_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Train Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_fn(learning_rate, save_model):\n",
    "    \"\"\"\n",
    "    Defines the training loop:\n",
    "    \n",
    "    1. Get Model\n",
    "    2. Get Dataset\n",
    "    3. Define custom metrics\n",
    "    4. Compile Model\n",
    "    5. Setup Tensorboard\n",
    "    6. Fit model on train dataset\n",
    "    7. Save Training history to HopsFS (Resources folder)\n",
    "    8. Save Trained model to HopsFS (Resources Folder)\n",
    "    9. Get the Validation Dataset\n",
    "    10. Evaluate Model on Validation Dataset\n",
    "    11. Save results on the validation set to HopsFS\n",
    "    12. Return Validation Accuracy\n",
    "    \"\"\"\n",
    "    # Tell Keras we are traning (in case it does different functionality between train/test time)\n",
    "    tf.keras.backend.set_learning_phase(True)\n",
    "\n",
    "    # 1. Get model\n",
    "    print(\"Defning the model\")\n",
    "    model = define_model()\n",
    "    print(\"Defining the model complete\")\n",
    "    \n",
    "    # 2. Get the train dataset\n",
    "    print(\"Getting the train dataset\")\n",
    "    train_dataset = create_tf_dataset(TRAIN_DATASET, SHUFFLE_BUFFER_SIZE, BATCH_SIZE, NUM_EPOCHS)\n",
    "    print(\"Getting the train dataset complete\")\n",
    "    # 3. Define custom metrics\n",
    "    def top3_acc(x, y):\n",
    "        return metrics.top_k_categorical_accuracy(x, y, k=3)\n",
    "    \n",
    "    def top5_acc(x, y):\n",
    "        return metrics.top_k_categorical_accuracy(x, y, k=5)\n",
    "    \n",
    "    # 4. Compile the model\n",
    "    print(\"Compiling the model\")\n",
    "    model.compile(optimizer=tf.train.AdamOptimizer(learning_rate), loss='categorical_crossentropy',  \n",
    "                  metrics=['accuracy', metrics.mae,top3_acc,top5_acc])\n",
    "    print(\"Compiling the model complete\")\n",
    "    # 5. Setup Tensorboard\n",
    "    print(\"Setting up tensorboard\")\n",
    "    tb_callback = TensorBoard(log_dir=tensorboard.logdir(), histogram_freq=0,\n",
    "                             write_graph=True, write_images=True)\n",
    "    callbacks = [tb_callback]\n",
    "    callbacks.append(keras.callbacks.ModelCheckpoint(tensorboard.logdir() + '/checkpoint-{epoch}.h5',\n",
    "                    monitor='acc', verbose=0, save_best_only=True))\n",
    "    print(\"Setting up tensorboard complete\")\n",
    "    # 6. Fit model on training dataset\n",
    "    print(\"Starting training...\")\n",
    "    history = model.fit(train_dataset, epochs=NUM_EPOCHS, steps_per_epoch = STEPS_PER_EPOCH, callbacks=callbacks)\n",
    "    print(\"Training complete\")\n",
    "    \n",
    "    # 7. Save training history to HopsFS\n",
    "    print(\"Saving training history log...\")\n",
    "    results_path = hdfs.project_path() + \"Resources/tinyimagenet_train_results_\" + \"lr=\" + str(learning_rate) + \".json\" \n",
    "    hdfs.dump(json.dumps(history.history), results_path)\n",
    "    print(\"Training history saved, final train top1 accuracy: {}\".format(history.history[\"acc\"][-1]))\n",
    "    \n",
    "    # 8. Save trained model to HopsFS \n",
    "    if(save_model):\n",
    "        try:\n",
    "            print(\"Saving trained model..\")\n",
    "            # Keras can't save to HDFS in the current version so save to local fs first\n",
    "            model.save(MODEL_NAME) #Keras can't save to HDFS in the current version so save to local fs first\n",
    "            # copy from local fs to hdfs\n",
    "            hdfs.copy_to_hdfs(MODEL_NAME, hdfs.project_path() + \"Resources/\", overwrite=True)\n",
    "            print(\"Trained model saved\")\n",
    "        except:\n",
    "            print(\"Exception while trying to save model to HDFS\")\n",
    "        \n",
    "    # 9. Get the validation dataset\n",
    "    print(\"Getting the validation dataset...\")\n",
    "    val_dataset = create_tf_dataset(VAL_DATASET, SHUFFLE_BUFFER_SIZE, BATCH_SIZE, 1)\n",
    "    print(\"Got validation dataset complete.\")\n",
    "    \n",
    "    # 10. Evaluate trained model on the validation dataset\n",
    "    print(\"Evaluating trained model on validation dataset...\")\n",
    "    score = model.evaluate(val_dataset, verbose=1, steps=1)\n",
    "    print(\"Evaluation on validation dataset complete.\")\n",
    "    \n",
    "    # 11. Save validation results to HopsFS\n",
    "    print(\"Saving validation results to HopsFS..\")\n",
    "    val_loss = score[0]\n",
    "    val_top1_acc = score[1]\n",
    "    val_mae = score[2]\n",
    "    val_top3_acc = score[3]\n",
    "    val_top5_acc = score[4]\n",
    "    validation_results = {\n",
    "        \"loss\": val_loss,\n",
    "        \"top1_acc\": val_top1_acc,\n",
    "        \"mae\": val_mae,\n",
    "        \"val_top3_acc\": val_top3_acc,\n",
    "        \"val_top5_acc\": val_top5_acc\n",
    "    }\n",
    "    val_results_path = hdfs.project_path() + \"Resources/tinyimagenet_val_results_\" + \"lr=\" + str(learning_rate) + \".json\" \n",
    "    hdfs.dump(json.dumps(validation_results), val_results_path)\n",
    "    print(\"Saved validation results: {}\".format(validation_results))\n",
    "    \n",
    "    # 12. Return validation accuracy\n",
    "    #return history.history[\"acc\"][-1]\n",
    "    return val_top1_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HyperParameter Search Experiments\n",
    "\n",
    "To run the differential evolution you should have started the jupyter notebook from the \"Parallel Experiments\" option, ideally using GPUs since we are training using a very compute-intensive network: ResNet50. If you use 5 parallel executors, then setting `population=5` is a good choice, and the number of generations will control for how many rounds the search will go on before returning. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 100\n",
    "NUM_EPOCHS = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "search_dict = {\"learning_rate\": [0.001, 0.01], \"save_model\" : [False, False]} # don't need to save model during hyperparam search\n",
    "log_dir, best_params = experiment.differential_evolution(\n",
    "    train_fn,\n",
    "    search_dict,\n",
    "    name='tiny_imagenet_hyperparam_search',\n",
    "    description='Evolutionary search through the search space of hyperparameters with parallel executors to find the best parameters for the tinyimagenet dataset',\n",
    "    local_logdir=True,\n",
    "    population=4,\n",
    "    generations = 6\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the Best HyperParameters to HopsFS\n",
    "The next notebook will read the best parameters and use those for training on a larger amount of epochs using a larger amount of GPUs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'learning_rate': '0.004086662546226794', 'save_model': '0'}"
     ]
    }
   ],
   "source": [
    "best_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "hdfs.dump(json.dumps(best_params), \"Resources/\" + HYPERPARAMS_FILE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot Results of Best HyperParameter Combination"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Training Results from HopsFS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%local\n",
    "import json\n",
    "from hops import hdfs\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import rcParams\n",
    "# Read the best hyperparameters\n",
    "best_hyperparams_path = \"Resources/\" + HYPERPARAMS_FILE\n",
    "best_hyperparams = json.loads(hdfs.load(best_hyperparams_path))\n",
    "best_learning_rate = best_hyperparams[\"learning_rate\"]\n",
    "# Read the training history for the training run with the best hyperparameters\n",
    "results_path = hdfs.project_path() + \"Resources/tinyimagenet_train_results_\" + \"lr=\" + str(best_learning_rate) + \".json\" \n",
    "results = json.loads(hdfs.load(results_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [5.411390064445596,\n",
       "  5.222174410669325,\n",
       "  5.116018927668456,\n",
       "  4.780339137980454,\n",
       "  4.4961224836919165,\n",
       "  4.197769415366419,\n",
       "  3.8981625394597574,\n",
       "  3.6129509233674995,\n",
       "  3.3779140673160066,\n",
       "  3.1467709290993446,\n",
       "  2.8962555218423423,\n",
       "  2.6263754996077124,\n",
       "  2.284546881883759,\n",
       "  1.9326494781492196,\n",
       "  1.5513498628175952,\n",
       "  1.0851616384603926,\n",
       "  0.6480491159371766,\n",
       "  0.40564116015726515,\n",
       "  0.3199676515479457,\n",
       "  0.2681495739255294],\n",
       " 'acc': [0.009054697310470356,\n",
       "  0.01697247675131099,\n",
       "  0.027627581932698732,\n",
       "  0.04670266684421948,\n",
       "  0.07914502121637235,\n",
       "  0.11595233486135557,\n",
       "  0.1565292457367363,\n",
       "  0.1990851497811158,\n",
       "  0.2382390739644947,\n",
       "  0.27630292084238944,\n",
       "  0.32105782131354016,\n",
       "  0.36813016951266414,\n",
       "  0.43375565930365545,\n",
       "  0.5073967380990311,\n",
       "  0.5909156239725398,\n",
       "  0.7019287993662462,\n",
       "  0.81601568986638,\n",
       "  0.8805464588781623,\n",
       "  0.9041652169067196,\n",
       "  0.9181189449555284],\n",
       " 'mean_absolute_error': [0.009941208226630933,\n",
       "  0.009922017659479325,\n",
       "  0.009901096389290025,\n",
       "  0.009852029950900058,\n",
       "  0.009750203106070087,\n",
       "  0.00959363685413876,\n",
       "  0.009373966205739829,\n",
       "  0.009092646672805273,\n",
       "  0.008823145325243413,\n",
       "  0.008515526273807132,\n",
       "  0.00815261508766315,\n",
       "  0.007731447663256912,\n",
       "  0.007122039600302988,\n",
       "  0.006415961795865305,\n",
       "  0.00555603962370729,\n",
       "  0.004352390208631891,\n",
       "  0.002987790056153046,\n",
       "  0.0020607287880881984,\n",
       "  0.0016822508381948798,\n",
       "  0.0014204712065789282],\n",
       " 'top3_acc': [0.03744203117310575,\n",
       "  0.05818823446157967,\n",
       "  0.07282429431526183,\n",
       "  0.10897650284299609,\n",
       "  0.16708383378435104,\n",
       "  0.22883301741698953,\n",
       "  0.29346830384933015,\n",
       "  0.3538808249977629,\n",
       "  0.40430082839502596,\n",
       "  0.4540445658470391,\n",
       "  0.5063781442688389,\n",
       "  0.5632805563927182,\n",
       "  0.6322951273086967,\n",
       "  0.7036243047067757,\n",
       "  0.7808360094992515,\n",
       "  0.8663235648813354,\n",
       "  0.9389188268984251,\n",
       "  0.9717098348731295,\n",
       "  0.9823445541049363,\n",
       "  0.9866564813374744],\n",
       " 'top5_acc': [0.053859275305277225,\n",
       "  0.08426908717873324,\n",
       "  0.11380895233269739,\n",
       "  0.15693570266759724,\n",
       "  0.2301350984490732,\n",
       "  0.3019943496745904,\n",
       "  0.37611182079584954,\n",
       "  0.4402483881552771,\n",
       "  0.49379307778967996,\n",
       "  0.5439275312678894,\n",
       "  0.595691040082323,\n",
       "  0.6517215717154784,\n",
       "  0.7175740338368275,\n",
       "  0.7800625800235799,\n",
       "  0.8448556747276119,\n",
       "  0.9136663711763667,\n",
       "  0.9652545258296497,\n",
       "  0.9870234527354576,\n",
       "  0.9928950104144735,\n",
       "  0.9951783936930237]}"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%local\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Loss/Epoch During Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f706410d978>]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"loss\"] #loss\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Loss per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Accuracy/Epoch During Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7064047b00>]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEWCAYAAABIVsEJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XeYVOXZx/HvzbL0zlKkuYAU6eCCqIktqMSGLVEssSQxmpjE5FVjYosliWI00cTeNYkaO1bEHqMIWEA6S5POUhcWlm33+8c5aw7rltllZ2dm9/e5rrlmTr/nzDPnPud5TjF3R0REpLoaJToAERFJTUogIiJSI0ogIiJSI0ogIiJSI0ogIiJSI0ogIiJSI0ogkrLM7GYze7COlvVDM3u5LpYlUhkzW25mo2t73JpISAIxsx2RV4mZ7Yp0n7WX8z7azN43s1wzWxDjNO3CGF7Ym2U3ZGZ2kZkVlfltd5hZx0THFgszWxKJudjM8iPdv3b3h9z9hFpYzngzy66NmGtTmIzdzE6M9GsV9usaw/RVfi8ze8rMdofrdLOZvWFm+9VC7E+F25HhkX5DzCw/xukvMrO3yvS72cwKy5TlbpHho83sCzPbaWbTzWxIBfOutFzV5Pu6e6a7z6jtcWsiIQnE3VuVvoCvgBMi/f65l7PfAdwP/K4a05wO7ASOresNnpk1rsvl1YZKYn4v+tuGr011GlwNuXvfSJmcAfwo8h1uT3R8dWQzcIOZWRyXcWO4jnsAW4D7amm+W4Aba2lepR4rU5bXAJhZc+Algu1Me+AZ4IXy/hfVLVeptj1IyiosM2tuZneZ2VozW2Vmt5pZejhsvJllm9n14V7MMjP7Xum07v5RmISWV2OR5wJ/BZYAE8vEkmlmL5nZxvB1W2TYT81sgZltN7MvzWyomTUL99p6RMZ7ysyuLhP/NWa2HrjHzDqZ2etmlhN+p5fMbJ/I9Blm9riZrTOzLWb2dNg/28yOiozXzMy2mdn+5azTStdbuM7/amYrw+X8zcyaVhRzNdZt6fzXmdkV4frabGb3l84/HP6zcG9tk5k9b2ZdIsOGm9k74XdfZ2b/F5l1czN7MvwNZpvZiOrGFmP8X++lRn7jC8OYt5jZX8JhLSw4+u0XmbZHuKfarpz5TjOz34d7sTvC797RzP4dzmdambJ0T/ifyA2nGRsZ1srM/mVmW81sjpn91iJHBWbWM1KWl5rZRWXCmQw0A75fwToot4xYsNP1AtDHYjzydPedBBvePX4vM/uJmS0My8irZtY97J9mwTYhJyzjs8xsQGTSh4CDzezACmLvEPkPrTSz68yskZmNJPjvHx7Gva6yuENHAfnufre77wZuA1oD34ph2rJxXWJmU83sXjPbAlxmZoPM7INwHWwws0fMrFVkmo2lv7uZ/Tn8Xk+H/4FZZja0huMeZMF2bLuZPRGWlSsriz8pEwhwPTAMGAocABwOXBEZngk0AboCPwYeM7PeNVmQmfUHxgL/Av5JkExKh6UDrwPzgV5AT+C5cNg5wG8IEk4b4DSCvaBYZALp4fx+QfA73Bsuo/R7/CUy/tOAAQOBLsBdYf/HgbMj400AFrn7/EqWW9F6u51gr3AoMADoD1xZZtpozDUxETgynP9I4HIAMzsWuAY4GegObASeCIe1B94Cng/j7g98EJnnycDDQDvgbYKNQV0ZT/A9RgHnm9nh4YbxWfb8Xc4CXnX3rRXM53SCjXYvgvX/X4LfuAOwArgqMu7H4TgdCfaCnwnLKcBNQCdgX+A44JzSicwsDXgN+AjoFsb+OzM7LDLvYuBa4Ppw/LLKLSPhUebJwNJYjzzNrDVwBhBNcKcDlwInEJTzz4F/hIOPJ1jPfQn2+s9kz/9bLjAJ+EMFi/wnsA3oA4wBTgLOcffPw2WWHj1Hq+tOCzfiX5rZjyL9BwOzSjvcvQSYE/aviSOAT4AM4I6w37UE62B4ON/KNuSnEhzJtSP4b/yluuOaWQvgxXD57YEpwLFVRu7uCX0RHCmMK9NvNXBkpHsCsCD8PB7IB5pFhk8GLi8zj+NLp6li+TcB08LPvQEH9g+7jwhjaVTOdO8DPymnf7NwHj0i/Z4Cro7EnwekVxLTWGBtJKYCoHU542US/Cmah92vAL+oYJ4VrjegcbiM7pFhRwDzqxHzRUAhsDXymhsZvg44L9J9Sulwgj/3DZFh7YASgoRxPvBxBcu8GXgl0j0K2FoLZXIacHY53++tMr9xVpl1eWn4+TAgOzLsS+DEyLrMLrOs/4t03wW8EOn+Xmn5LCdOI6h6HRB2rwEOiwy/pHRZYUyLy0x/PXBPZF0+GM7zi3C9twq/Z9cYy0h2eXGW+R/sCsuGEySPQZHh7wJnRbrTwzLVhWBjNpdg49+onPleDbQA1hLscA4hOEqAIKHuUX7D7/d62d82MnxI+L3TgEOBHODkcNgfgEfLjP8cQTKtbrm6BJhXxXRnA/+JdG8Exoaf/wy8GBk2BthY3XHD9buozHK/qOo7Jd0RiJkZwQ+3ItJ7BcGeaakcd88vM7wb1RQu6xyCDRjuvoxgD6/0KKQnsMyDPYyyehJUedXEOncvjMTR2sweNrOvzCwXeJNgb6R0ORvcfXvZmbj7coK9tJPMrBPB3v1TlSy3ovXWjeDPOjes/thKsDfSuaKYK/C+u7eLvMruka0sZ9mE71//3h7sqecS/OZVredolcNOgo3eN1hQdVdavVJbRykVLfsDIC2sEhgB7ENwJFuR9ZHPu8rpjlZf/Das4tlGsAfeDMgws0YE/5voOo5+3hfILP19w9/41+E0X/Ngy3ENwR5wemRQLGUkFn9w93YERwLFQLQRfV/g3sj8c4AigqOe1wmqqe4D1pnZ3dFqnTD2ncAf+eZRyL4E6yknMu87CBJTudx9jruvc/did/+AILGfFg7eQVDrENUG+MZ/NEbR36m0yvNZM1sTbg/u5X/bg/LE9B+oYtxuwKrK4ipP0iWQsACvI/jRS/UiOBIolWFmzcoMX1ODxR0RTvv7sG50HcEh49nhH3IlwZ+uvPW0kuBwuqwCgr2mFpF+Zc9iKXsL5CsJ/iSj3b0NcDTBnmDpcjqX/bNEPEawh3IG8I67b6hgPKh4va0l+KP2jWz827p7tB67Nm7b3LOcZRO+f/17W9BW0IbgN69oPVeLu1/n/6teuXRv51fFspz/VS+eAzwVQ/KtkgXtXT8nqC5qR1DFtQuwcCdnPUE5KhVd3ysJjsijCb61u59cTvwvh/P6caR3VWWkWuUj3Fm7DPibmTWJxHhemRibu/unHrjd3UcSVG8PB35ZzqzvC9dBtPplJcFGv31kvm3cfVQ1Ynf+95+cGy4fgHD7MCTsXxNll38bQc3CoHB7cFFk2fGylj3LDuxZfsqVdAkk9CRwnQWNiZ0J6oD/ERmeDlxjZk3M7EiCRq3StolG4UYyPei0ZpE64rLOJaj2GUzQmDeCoGB0AL4DfEiwV3GjBY2jzc3s4HDaB4ErLWjgNTPrb2Y9wj/yl8BZFjT8nQgcVMX3bU2wN7DVzDIIDseBr/9oHwB/N7O24Xc+NDLtswSNdxcTbLQqU+56CzduDwN3WNBgbxY0uB5V6dyq7xdmtk/4Ha8kaNuB4Pf+sQWnXjYjqE55x93XEezl7mdmF4dxt7E4ntdeix4naNeYSNW/S6xaE+yc5BC0Zd1AsGdd6t/AVWE56UVQJkp9CGBml4b/icZmNszMRlG+qwja+ACIoYysp/IdnW8IE1UuQXUSBHvaV1vYOG5m7c3s1PDzWDPLsuAspTyCHbVv1Ay4e0G4XqKxLyOoPpoUHu03MrN+Zlba6L0e6BndTpjZyeF6NDM7CPgZQZsTwFSCkzcusuBEkF+FMX0Y63evQmuC7U6umWWG84+3d4F2ZnZBWDbOJIY2nWRNINcC8wgy+hcEjYqTIsOXE+wNrSMo1Oe7+9Jw2NEEe2XPEzTy7QK+cQFYWNBPBe4MD1VLX9kE1UDnhn+aYwmSyiqCU45PBnD3JwgaFZ8l+LGfJdgrhKBe83SCKoaTCJJUZf5McIi6iaAQvlZm+ESCjf/i8Dt/vWEIq7ZeJjgEnVzFcpZT8Xq7lOBIYCbB3s8b7Fm9EIvSM1mir6GR4U8RFNTFBEl2UvgdXgH+FMa/huCI7Zxw2BaCRHcGsAFYSA3Odqlr7r6EINbt7j69lmb7MsHOxBJgKUH9dk5k+NUEZW4FQZXPv4HdYTylZfngcHgOwdl05W7w3f1tIg3FocrKyCyC329FWE3UIcbv9GeCHbF0d38S+DvwfFh18wXBbw/Bf+tRgvaTpeF3uOObswOCo/KyjfgTw3ksIDhd+Wn+V4X1BsF/Y4OZlVbjnBP2207wX7nO3Z8GcPddBO2yF4XxnAGc5O5FMX7nqlxNUDuSS7BdeaaW5luhsPrvZIJqzS0EZeUtwvJTEQsbS1KGmY0H/u7ue30BUn1hZn8EOrv7jyoZJ6HrLawePM3da2svLemZ2b8IGkhvStDyfwWMd/djErF8SW1mNge43t0rTGDJegQiMbKg8fw8gouaJElYcIX18cAjdbjMnmFVTyMzG0zQRqC7K0hMzOxIC65JSzeznxK0U75d2TRKICnMzC4hOMx+pharSWQvmdkkgrPjbnD31VWNX4uaElS3bCeolnmKoK1OJBbDCJoNthCcQHGyu2+ubIKUq8ISEZHkoCMQERGpkZS6cRdARkaGZ2ZmJjoMEZGU8umnn2509061Oc+USyCZmZnMnDkz0WGIiKQUM1tR9VjVoyosERGpESUQERGpESUQERGpESUQERGpESUQERGpESUQERGpESUQERGpkZS7DkREpKFwd9Zuy2fumlzmrcnlO/t3Zkj3tokO62tKICIiSaCouISlG/OYtyaXuWu2MW9tkDS27AweZmkGHVo1UQIREWnIdhYUMX/t9jBJbGPemlwWrNvO7qLgIYtNGjdiYNfWHDO4K4O7tWFQt7YM7Nqalk2Ta5OdXNGIiNRDS3N28Pb8DcxevY25a7axbGMepTdCb9s8nUH7tOGcsfsyqFsbBndrS59OLUlPS/4maiUQEZFa5u7MW5vLlDnreGPuOhat3wFA93bNGdStDScM6xYeWbShe7vmmFmCI64ZJRARkVpQUuJ8vnILb4RJY+XmXTQyGJ3ZgetOGMTRg7vSvV3zRIdZq5RARERqqLC4hOnLNvPGnHVMmbuODdt3k55mHLJfBj87fD/GDepCRqumiQ4zbpRARESqIb+wmA8Xb+SNuet4a/56tu4spFl6Iw7v35nxQ7py5P6dadMsPdFh1gklEBGRKrg7U+au4+XZa3lvwQbyCopp3awx4/bvwjGDu3JY/040b5KW6DDrnBKIiEglCotLuObFOTw1YyUZrZpw4ojujB/SlYP6dKRJ4+Q/UyqelEBERCqwY3cRP/vnZ7y/KIdLjtiPXx3Vn7RGqXnGVDwogYiIlGN9bj7nPzKDheu386dThjJxTK9Eh5R0lEBERMpYtH475z08na27Cnnw3CyOGNA50SElJSUQEZGIj5Zs5CdPfEqz9DT+/ZODkureU8lGCUREJPTi56u5/NlZZHZsySPnj6ZH+xaJDimpKYGISIPn7tz93hJunbKQsX06cN/ZWbRt0TCu5dgbSiAi0qAVFZdwzUtzeHL6SiaM6Mak04bRtHHDu6ajJpRARKTByttdxM/+9RnvLczhZ0f05bKjB6TsjQ0TQQlERBqkDbn5XPDYDOav3c4fTx7KmQfqNN3qUgIRkQZn8frtnPfIDLbsLODBH2RxxECdplsTSiAi0qBMW7qJCx+fSdP0NJ6+8CCG9tBpujWlBCIiDcZLX6zm8mdm06tjCx45bzQ9O+g03b2hBCIiDcI97y3hljcWcGDvDtx/jk7TrQ1KICJS7706ey23vLGAE4Z348/f02m6tSWu9yI2s/FmttDMss3synKG9zKzd83sczObbWbHxjMeEWl4tu4s4LrJcxjavS1/+f5wJY9aFLcEYmZpwF3Ad4FBwEQzG1RmtKuBf7v7SOAM4O54xSMiDdONr8xn685Cbjl1GI3TGvbzO2pbPNfmGCDb3Ze6ewHwFDChzDgOtAk/twXWxDEeEWlgPliUw3OfreInh/VhULc2VU8g1RLPBNIdWBnpXhX2i/o9cLaZrQJeA35e3ozM7EIzm2lmM3NycuIRq4jUM3m7i/jdC1/Sp1NLfn5kv0SHUy8l+nhuIvCou/cAjgWeMLNvxOTu97t7lrtnderUqc6DFJHUc9ubi1i1ZRe3nDqMZulq94iHeCaQ1UDPSHePsF/UD4F/A7j7x0AzICOOMYlIA/DZV1t45KNlnDN2X0Zndkh0OPVWPBPIDKCfmfU2syYEjeSTy4zzFfAdADPbnyCBqI5KRGqsoKiEK5+bTdc2zbhi/IBEh1OvxS2BuHsRcAkwBZhPcLbVXDO7wcxODEf7P+DHZjYLeBI4z909XjGJSP1393vZLFq/gz+cPITWzXSxYDzF9UJCd3+NoHE82u/ayOd5wCHxjEFEGo5F67dz17vZTBjRjSMHdkl0OPVeohvRRURqRXGJc8Wzs2nVtDHXHl/2kjOJB93KRETqhcc+Ws4XK7dyxxkj6NiqaaLDaRB0BCIiKW/l5p3cOmUhRwzoxInDuyU6nAZDCUREUpq787sXvqSRwU0nD9UjaeuQEoiIpLTnPlvNfxZv5MrvDqR7u+aJDqdBUQIRkZSVs303N74yj9GZ7TnrwH0THU6DowQiIinr95PnsqugmD+dMoxGjVR1VdeUQEQkJb05dx2vfrmWX47rx36dWyU6nAZJCUREUs62XYVc89Ic9t+nDRce2ifR4TRYSiAiknJufn0+Odt3c8upQ0nXQ6ISRmteRFLKx0s28eT0lfzo230Y1qNdosNp0JRARCRl5BcW89vnZ7Nvxxb8alz/RIfT4OlWJiKSMv7y1iKWb9rJv358IM2b6CFRiaYjEBFJCV+u2sYDHyzljNE9ObivnjuXDJRARCTpFRaXcMVzs8lo1ZTfHrt/osORkKqwRCTp3fveEuavzeW+cw6gbXM9JCpZ6AhERJLagnW53PnOYk4Y3o1jBndNdDgSoQQiIkmrsLiEy56ZRZtm6Vx/4uBEhyNlqApLRJLW/R8sZc7qXO45axQdWjZJdDhSho5ARCQpLVy3nb++tYjjhu3Dd4fuk+hwpBxKICKSdIqKS7j82Vm0bpbODaq6SlqqwhKRpPPAf5Yxe9U27jpzlJ5vnsR0BCIiSWXx+u38Zeoijh3aleOGqeoqmSmBiEjSKCou4bJnZ9OyaRo3TBiS6HCkCqrCEpGk8dCHy5i1cit3ThxJhqqukp6OQEQkKWRv2MFtUxdxzOAunKCqq5SgBCIiCVdc4lz+7CxaNEnjxpOGYKbnm6cCVWGJSMI9/OEyPv9qK3ecMYLOrZslOhyJkY5ARCShluTs4M9vLuSoQV04cXi3RIcj1aAEIiIJU1ziXPHsbJqlp/EHVV2lHCUQEUmYR/67jE9XbOG6EwbRuY2qrlKNEoiIJMSyjXncOmUh3xnYmZNHdk90OFIDVSYQM9Pjv0SkVpWUOFc8O4umjRvxx1OGquoqRcVyBPKwmX1sZheaWeu4RyQi9d5jHy9nxvItXHvCYLqo6iplVZlA3P0g4AKgH/CFmT1uZkfEMnMzG29mC80s28yurGCc75vZPDOba2b/qlb0IpJylm/M45Y3FnDEgE6cOkpVV6ksputA3H2+mf0G+Aj4O3CQmRUCv3X3l8qbxszSgLuAo4BVwAwzm+zu8yLj9AN+Cxzi7lvMrPPefR0RSWYlJc4Vz80mPa0RfzplmKquUlwsbSCDzOxWYD4wHjjZ3fsBxwB3VjLpGCDb3Ze6ewHwFDChzDg/Bu5y9y0A7r6hBt9BRFLEE9NWMH3ZZq45bhBd26rqKtXF0gbyADAPGOXuP3H36QDuvhK4rpLpugMrI92rwn5R/YH+ZvZfM5tmZuPLm1HY/jLTzGbm5OTEELKIJJuvNu3k5tcXcGj/Tnwvq0eiw5FaEEsV1jhgt7uXAFhwzNnU3fPd/dFaWH4/4HCgB/CBmQ11963Rkdz9fuB+gKysLN/LZYpIHQuqrmaR1si4WWdd1RuxHIG8A7SMdLcK+1VlNdAz0t0j7Be1Cpjs7oXuvgxYRJBQRKQeuWXKAqYt3czVx+1Pt3bNEx2O1JJYEkhzd99e2hF+bhHDdDOAfmbW28yaAGcAk8uM8yLB0QdmlkFQpbU0hnmLSIp47KPl3Pf+Us4e24vTR/esegJJGbEkkJ1mNry0w8xGAPlVTeTuRcAlwBSCBvh/u/tcM7vBzE4MR5sCbDKzecC7wOXuvqm6X0JEktMbc9bx+5fnMm7/Llx/ou51Vd+Ye+VNCmZ2IPAksAIwgmqpiaWN6XUtKyvLZ86cmYhFi0g1fLpiC2c+MI3992nDkz8eS/MmaYkOqUEzs0/dPas251llI7q7fxLezqT0libzwtNyRUTKtTRnBz96bAb7tG3GQ+dmKXnUU7E+UKo30AdoBgwyM9xdV42LyDds3LGb8x6ZgZnx6Plj6Khnm9dbVSYQM7saOBoYSNBmcQzwIaAEIiJ72FlQxA8fncGG7fk8+eOxZGa0rHoiSVmxNKKfDhwBrHX3c4Dh7Hlar4gIRcUl/Pxfn/Pl6m38beIoRvZqn+iQJM5iSSC73L0YKArvxrsO2De+YYlIKnF3rnlpLm8v2MD1E4Zw1KAuiQ5J6kAsbSCfm1k74GFgJpALJOQMLBFJTne/t4Qnp3/FxYf35Zyx2r9sKCpNIOFtS34f3lrkLjObArRx98/qJDoRSXrPf7aKW6cs5KQR3bj86AGJDkfqUKUJxN3dzKYCQ8Lu7DqJSkRSwoeLN3LFs7M5uG9HJp02nEaNdKFgQxJLG8gXZjYy7pGISEqZtyaXi/7xKX07teLecw6gSeNYNidSn8TSBjKS4GFQS4A8gqvR3d1HxTUyEUlaa7bu4vxHp9OqaWMeOX80bZqlJzokSYBYEsiJVY8iIg3Ftl2FnPfIdHbuLuaZiw/S3XUbsFgSyK64RyEiKWF3UTE/eWImyzbm8dj5YxjYtU2iQ5IEiiWBvA04QdVVM4KbKS4BdLqFSANSUuJc/sxspi3dzF9PH8HB+2UkOiRJsFhuprh/tNvMxgA/iltEIpKUJk1ZyORZa7hi/ABOGln26dTSEFX7tInwNu5j4xCLiCSpu9/L5t73l3D22F5cfFjfRIcjSSKWmyn+ItLZCDgAWB+3iEQkqdz1bja3TlnIhBHd9FAo2UMsbSCdIp+LgLeAZ+ITjogkk2jyuP37I0jThYISEUsbyDV1EYiIJBclD6lKlW0gZvZGeDPF0u72ZvZqfMMSkURS8pBYxNKI3jW8mSIA7r4F6Ba/kEQkkZQ8JFaxJJBiM+tR2mFmveIYj4gkkJKHVEcsjejXAv81s3cILiY8HLg4nkGJSN1T8pDqiqUR/dXw4sGDwl5XuPuG+IYlInVJyUNqIpZG9BOBfHd/0d1fBArM7Pj4hyYidUHJQ2oqljaQG9x9W2lH2KB+Y/xCEpG6ouQheyOWBFJeiYql7UREkpiSh+ytWBLI52Y2ycz2DV+3Ap/HOzARiR8lD6kNsSSQS8LxXgpfoLOwRFKWkofUlljOwtoBXFbabWZNgOOAF+IYl4jEgZKH1KaYbuduZo3M7GgzewT4Cjg3vmGJSG1T8pDaVukRiJkdApwJnEDQ7jEW6BselYhICigpcSZNWci97y9R8pBaVWECMbMVwBrgfuAqd99qZsuUPERSR0FRCb95bjYvfL6aMw/sxY0Thih5SK2p7AjkZeBEYAKQZ2YvEzwbXURSwPb8Qi7+x2d8mL2Ry47uz8+O2E8Pg5JaVWEbiLtfAmQCdwHjgWygk5mdYmYt6iY8EamJDbn5nH7fND5euolbTxvGJUf2U/KQWldpG4i7lwBTganh2VfHAhMJqrUy4h+eiFTXkpwdnPvwdDbnFfDguVkcMaBzokOSeiqms7AA3L0gvB/W6cC+sUxjZuPNbKGZZZvZlZWMd6qZuZllxRqPiHzTpyu2cOo9H5FfWMxTF45V8pC4ijmBRLl7XlXjmFkaQfXXd4FBwEQzG1TOeK2BXwKf1CQWEQm8OXcdZz4wjXbN03nu4oMZ1qNd1ROJ7IUaJZAYjQGy3X2puxcATxE0yJd1I3ALkB/HWETqtX9+soKL/vEpA7u25tmLD2bfji0THZI0APFMIN2BlZHuVWG/r5nZKKCnu1f6jHUzu9DMZprZzJycnNqPVCRFuTu3vbmQq16Yw2H9O/HkhWPJaNU00WFJA1GjBGJm9+ztgs2sEXA78H9Vjevu97t7lrtnderUaW8XLVIvFBaXcPmzs/nbO9mcntWTB36QRYsmulG21J3KLiRsU9Eg4HiqvqHiaqBnpLtH2K9Ua2AI8F54emFXYLKZnejuM6uYt0iDlre7iJ/+8zPeX5TDL7/Tj0vH6TRdqXuV7a5sIdjgR0ulh91dYpj3DKCfmfUO53MGwW1RghkFD6n6+lRgM3sPuEzJQ6RyG3fs5oJHZzBn9Tb+dMpQJo7pleiQpIGqLIEsA45w95VlB5jZN/qV5e5FZnYJMAVIAx5297lmdgMw090n1zRokYZq+cY8zn1kOutz83ngB1l8Z/9Y9uVE4qOyBHIn0IE9G8JL3R7LzN39NeC1Mv2urWDcw2OZp0hD9cXKrVzw6AwAnvzxWEb2ap/giKShqzCBuPudlQz7S3zCEZGySkqcf36ygj++toCM1k147Pwx9OnUKtFhiVT9QCkzawr8BPgWQRvIh8D97r47zrGJNHiL12/nyue/5NMVW/h2vwxu+/5wOrduluiwRIAYEgjwGLAbeCDsPjPsd0a8ghJp6HYXFXPPe0u4691sWjZtzG3fG84po7rrTCtJKrEkkGHuHr0FyVQzmxevgEQauk9XbOY3z31J9oYdTBjRjWuOH6SLAyUpxZJAZpnZaHefAWBmBxA8nVBEatH2/EJunbKQJ6atoFvb5jxy/mjdDFGSWiwJZCjwiZktDbt7A/PN7HPA3X1U3KITaSCmzlvPNS/OYf32fM47OJPLjh5Ay6a6qlySWywltLza+8qnAAASfklEQVQbIIpILdiwPZ/rJ8/j1S/XMrBra+45e5ROz5WUUWUCcfclZjYY+HbY6z/uPje+YYnUb+7OMzNXcdOr88gvKuHyYwZw4aF9SE+L5/1NRWpXLKfxXgL8FHgx7PVvM7vL3e+Oa2Qi9dSyjXn87vkv+XjpJsb07sCfThlKX13XISkoliqsC4Ex7r4DwMz+CHwEKIGIVENhcQkP/Gcpd7y1mCaNG/GnU4ZyelZPGjXSqbmSmmJJIAYURLoL2fMGiyJShc++2sJVL8xh/tpcxg/uyvUTBtOljS4IlNRW2e3cG7t7EfAEwVlYz4WDTia4kFBEqrAlr4BJUxbw5PSVdGnTlHvPPoDxQ7omOiyRWlHZEch0YJS7Twpvtf6tsP9FpdeEiEj5SkqcZz5dyc2vLyA3v4gffas3lx7Vn1Y6NVfqkcpK89fVVO4+nSChiEgV5q7ZxjUvzuGzr7YyOrM9N540hIFdK3o+m0jqqiyBdDKzX1c00N1juqW7SEORm1/I7W8u4vGPl9O+RRP+/L3hnKr7V0k9VlkCSQNaoQZzkUq5O5NnreGmV+ezccduzjqwF5cfPZC2LdITHZpIXFWWQNa6+w11FolICsresJ1rXpzLx0s3MaxHWx46N4thPdolOiyROhFTG4iI7GlnQRF3vp3NQx8upXl6GjedNISJY3qRpms6pAGpLIF8p86iEEkR7s6b89Zzw8vzWL11F6cd0IMrvztQt1uXBqmyR9purstARJLdV5t2ct3kOby7MIeBXVvzzEUHMTqzQ6LDEkkYnZQuUoVNO3Zz7/tLeOzjFaQ3Mq4+bn/OPThTNz6UBk8JRKQC23YV8uB/lvLwh8vYVVjMSSO7c8UxA+naVrcgEQElEJFvyNtdxCP/Xcb9HywlN7+I44btw6/G9WO/zq0THZpIUlECEQnlFxbzj2kruPu9JWzOK2Dc/p359VEDGNRNV5GLlEcJRBq8gqISnp65kr+/s5j1ubv5dr8Mfn1Ufz0ZUKQKSiDSYBUVl/D856u5463FrN66i9GZ7bnjjJGM7dMx0aGJpAQlEGlwSkqcV75cy1+nLmLpxjyG9WjLH08ZyqH9MnTfKpFqUAKRBsPdmTpvPbdPXcSCddsZ0KU1951zAEcP6qLEIVIDSiDSIHy4eCO3TlnArFXb6JPRkjsnjuT4ofvocbIie0EJROq1L1ZuZdIbC/hoySa6t2vOpNOGccrI7jTWRYAie00JROql7A3b+fOURbwxdx0dWzbhuhMGceaBvWjaOC3RoYnUG0ogUq+s2bqLv761iGc/XUXz9DR+Na4/P/x2bz1KViQO9K+SemFLXgF3v5fNYx+vAIfzD+nNTw/vS0fdJVckbpRAJKXl7S7i4Q+D247kFRRx6qge/HJcP3q0b5Ho0ETqvbgmEDMbD9xB8HjcB9395jLDfw38CCgCcoAL3H1FPGOS+qGgqIQnp3/F395ZzMYdBRwzuAuXHT2Afl10vyqRuhK3BGJmacBdwFHAKmCGmU1293mR0T4Hstx9p5ldDEwCTo9XTJL6ikucybNWc9ubi1i1ZRdj+3Tg/h8MZJRuOyJS5+J5BDIGyHb3pQBm9hQwAfg6gbj7u5HxpwFnxzEeSWHuzjsLNnDrlIUsWLedwd3a8IeTdfW4SCLFM4F0B1ZGulcBB1Yy/g+B18sbYGYXAhcC9OrVq7bikxSxYF0uN7w8j4+WbCKzYwv+NnEkx+kiQJGES4pGdDM7G8gCDitvuLvfD9wPkJWV5XUYmiTQ5rwCbp+6kH998hVtmqdzw4TBTBzTS08CFEkS8Uwgq4Geke4eYb89mNk44CrgMHffHcd4JEUUFpfwj2kr+MvUReQVFPODgzK5dFw/2rVokujQRCQinglkBtDPzHoTJI4zgDOjI5jZSOA+YLy7b4hjLJIi3l+Uw42vzCN7ww6+3S+Da44fRH+dWSWSlOKWQNy9yMwuAaYQnMb7sLvPNbMbgJnuPhm4FWgFPBM2hH7l7ifGKyZJXss25nHTK/N4e8EG9u3Yggd+kMW4/TurgVwkicW1DcTdXwNeK9Pv2sjncfFcviS/3PxC/v5ONo/8dxlNG6fx2+8O5LxDMnXPKpEUkBSN6NLwFJc4z366klunLGRTXgHfO6AHlx0zgM6tmyU6NBGJkRKI1LkZyzdz/ctzmbM6lwP2bc/D541mWI92iQ5LRKpJCUTqzOqtu7j59QW8PGsN+7Rtxh1njODE4d3UziGSopRAJO527C7ivveX8MB/luIOv/xOP35yWB9aNFHxE0ll+gdL3BQWl/DUjJXc8dYiNu4o4ITh3fjN+AG6U65IPaEEIrXO3Zk6bz03v7GApTl5jOndgYfO3Z/hPdXOIVKfKIFIrfpi5Vb++Op8pi/fTN9OLXU9h0g9pgQiteKrTTuZNGUBr8xeS0arJtx00hDOGN2TxrpvlUi9pQQie2XrzgL+9k42j3+8nMaNGvGLI/fjwsP66hnkIg2A/uVSI/mFxTz+8XL+/k42O3YX8b0DevLro/vTpY0uBBRpKJRApFpKSpyXZ69h0hsLWb11F4cP6MSV3x3IwK5tEh2aiNQxJRCJ2cdLNvHH1+bz5eptDNqnDZNOG8Yh+2UkOiwRSRAlEKnSpys289e3FvOfxRvp1rYZt39/OCeN6K4nAoo0cEogUqFo4ujYsgm/O3YgPzgok2bpulOuiCiBSDlmLt/MHW/vmTjOHruvbj0iInvQFkG+psQhItWhLYPskTgyWjXhqmP356yxvZQ4RKRS2kI0YDOXB20cH2YrcYhI9WlL0QApcYhIbdAWowFR4hCR2qQtRz1XXOK8OXcdD324jJkrtihxiEit0RaknsrNL+TfM1by6EfLWbVlFz07NOea4wcxcUxPJQ4RqRXaktQzX23aySMfLeOZmavYsbuIMZkduPq4QRw1qAtpunJcRGqREkg94O5MX7aZhz5cxtT560kz44Th3bjgkN4M7dE20eGJSD2lBJLCCopKeGX2Gh7+7zLmrM6lXYt0fnp4X35wUKZuqy4icacEkoI25xXwr09W8PjHK9iwfTd9O7XkDycP4ZSRPWjeRPepEpG6oQSSQhav387D/13O85+tYndRCd/ul8Gk04ZxaL9OujOuiNQ5JZAktm1XIZ8s3cRHSzbx0ZKNLFq/g6aNG3HKqO6cf0hv+ndpnegQRaQBUwJJIjsLipi5fMvXCWPO6m2UODRLb8TozA6cdkAPTh3Vg46tmiY6VBERJZBEKigq4YuVW/loyUY+WrKJz7/aQmGx07iRMbJXO35+ZD8O7tuREb3a0bSx2jZEJLkogdSh4hJn7ppt4RHGJmYs28yuwmLMYEi3tlxwSG8O3i+D0ZntdbGfiCQ9baXiIG93Ecs35bF8406Wb8pj2cY8lm/MY+H67WzPLwKgX+dWfD+rBwfvl8HY3h1p2yI9wVGLiFSPEkgN5RcWh0kij2UbdwbvYfeG7bv3GLdT66b07tiS44d1Y2yfDhzUtyOdW+s6DRFJbUogFcjbXcS63HzWbQtfufms3rqL5eHRxJpt+XuMn9GqCZkdW3Jo/05kdmxBZkZLMju2JDOjJa2aajWLSP3T4LZs7s6WnYWs3baL9bn5rN2Wz/ptwfvXCSM3/+uqpqj2LdLZt2NLDuzTkd4ZQXLo3bEl+2a0oE0zVUGJSMMS1wRiZuOBO4A04EF3v7nM8KbA48ABwCbgdHdfHo9Ynp7xFXe9u4R1ufkUFJXsMayRBdVMXds2p0+nlhyyXwZd2jRjn7bN9njXVd4iIv8TtwRiZmnAXcBRwCpghplNdvd5kdF+CGxx9/3M7AzgFuD0eMTTsWVTRvRst2dSaBu8d2rVlMZpjeKxWBGReiueRyBjgGx3XwpgZk8BE4BoApkA/D78/CzwdzMzd/faDmbcoC6MG9SltmcrItJgxXO3uzuwMtK9KuxX7jjuXgRsAzqWnZGZXWhmM81sZk5OTpzCFRGR6kiJeht3v9/ds9w9q1OnTokOR0REiG8CWQ30jHT3CPuVO46ZNQbaEjSmi4hIkotnApkB9DOz3mbWBDgDmFxmnMnAueHn04B34tH+ISIitS9ujejuXmRmlwBTCE7jfdjd55rZDcBMd58MPAQ8YWbZwGaCJCMiIikgrteBuPtrwGtl+l0b+ZwPfC+eMYiISHykRCO6iIgkHyUQERGpEUu1NmszywFWJDqOCmQAGxMdRCUU395J9vgg+WNUfHtnb+Lb191r9TqIlEsgyczMZrp7VqLjqIji2zvJHh8kf4yKb+8kW3yqwhIRkRpRAhERkRpRAqld9yc6gCoovr2T7PFB8seo+PZOUsWnNhAREakRHYGIiEiNKIGIiEiNKIFUk5n1NLN3zWyemc01s1+WM87hZrbNzL4IX9eWN684xrjczL4Mlz2znOFmZneaWbaZzTazUXUY24DIevnCzHLN7NIy49T5+jOzh81sg5nNifTrYGZTzWxx+N6+gmnPDcdZbGbnljdOHGK71cwWhL/fC2bWroJpKy0LcY7x92a2OvI7HlvBtOPNbGFYHq+sw/iejsS23My+qGDauK7DirYpyVL+KuXuelXjBewDjAo/twYWAYPKjHM48EoCY1wOZFQy/FjgdcCAscAnCYozDVhHcIFTQtcfcCgwCpgT6TcJuDL8fCVwSznTdQCWhu/tw8/t6yC2o4HG4edbyostlrIQ5xh/D1wWQxlYAvQBmgCzyv6f4hVfmeG3AdcmYh1WtE1JlvJX2UtHINXk7mvd/bPw83ZgPt980mKymwA87oFpQDsz2ycBcXwHWOLuCb+zgLt/QHBH6KgJwGPh58eAk8qZ9BhgqrtvdvctwFRgfLxjc/c3PXiKJ8A0guftJEwF6y8WXz/62t0LgNJHX9eqyuIzMwO+DzxZ28uNRSXblKQof5VRAtkLZpYJjAQ+KWfwQWY2y8xeN7PBdRoYOPCmmX1qZheWMzyWxw3XhTOo+E+byPVXqou7rw0/rwO6lDNOMqzLCwiOKMtTVVmIt0vCaraHK6iCSYb1921gvbsvrmB4na3DMtuUpC9/SiA1ZGatgOeAS909t8zgzwiqZYYDfwNerOPwvuXuo4DvAj8zs0PrePlVsuAhYycCz5QzONHr7xs8qC9IunPezewqoAj4ZwWjJLIs3AP0BUYAawmqiZLRRCo/+qiTdVjZNiVZy58SSA2YWTrBD/1Pd3++7HB3z3X3HeHn14B0M8uoq/jcfXX4vgF4gaCaICqWxw3H23eBz9x9fdkBiV5/EetLq/bC9w3ljJOwdWlm5wHHA2eFG5hviKEsxI27r3f3YncvAR6oYNkJLYsWPEr7FODpisapi3VYwTYlqcsfKIFUW1hf+hAw391vr2CcruF4mNkYgvVcJ896N7OWZta69DNBY+ucMqNNBn4Qno01FtgWOVSuKxXu9SVy/ZURfeTyucBL5YwzBTjazNqHVTRHh/3iyszGA1cAJ7r7zgrGiaUsxDPGaLvayRUsO5ZHX8fTOGCBu68qb2BdrMNKtilJW/6+Vlet9fXlBXyL4FByNvBF+DoWuAi4KBznEmAuwRkl04CD6zC+PuFyZ4UxXBX2j8ZnwF0EZ798CWTV8TpsSZAQ2kb6JXT9ESSztUAhQT3yD4GOwNvAYuAtoEM4bhbwYGTaC4Ds8HV+HcWWTVD3XVoG7w3H7Qa8VllZqMP190RYvmYTbAz3KRtj2H0swZlHS+IVY3nxhf0fLS13kXHrdB1Wsk1JivJX2Uu3MhERkRpRFZaIiNSIEoiIiNSIEoiIiNSIEoiIiNSIEoiIiNSIEohIGWZWbHveMbjW7hBrZpnRO8KKpLLGiQ5AJAntcvcRiQ5CJNnpCEQkRuFzISaFz4aYbmb7hf0zzeyd8KaBb5tZr7B/Fwue1TErfB0czirNzB4In/3wppk1T9iXEtkLSiAi39S8TBXW6ZFh29x9KPB34K9hv78Bj7n7MIKbGt4Z9r8TeN+Dm0KOIriSGaAfcJe7Dwa2AqfG+fuIxIWuRBcpw8x2uHurcvovB45096Xhze/WuXtHM9tIcJuOwrD/WnfPMLMcoIe7747MI5Pg+Q39wu7fAOnuflP8v5lI7dIRiEj1eAWfq2N35HMxaouUFKUEIlI9p0fePw4/f0RwF1mAs4D/hJ/fBi4GMLM0M2tbV0GK1AXt+Yh8U3Mz+yLS/Ya7l57K297MZhMcRUwM+/0ceMTMLgdygPPD/r8E7jezHxIcaVxMcEdYkXpBbSAiMQrbQLLcfWOiYxFJBqrCEhGRGtERiIiI1IiOQEREpEaUQEREpEaUQEREpEaUQEREpEaUQEREpEb+H6dJWDxRJDRRAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"acc\"] #acc\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Top1 Accuracy per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Top1 Accuracy\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f706409fe48>]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"top3_acc\"] #acc\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Top3 Accuracy per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Top3 Accuracy\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f705c5f2780>]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"top5_acc\"] #acc\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Top5 Accuracy per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Top5 Accuracy\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run single training experiment with a set of hyperparameters using a single GPU\n",
    "\n",
    "Running 30 epochs (1.5hours on single GPU) with the following learning rate yields Top1Acc: 0.73 | Top3Acc: 0.90 | Top5Acc: 0.94 on the training set:\n",
    "\n",
    "- lr: 0.01\n",
    "- batch_size: 100\n",
    "\n",
    "The accuracy can be further improved by training more epochs, and to improve the accuracy on the validation set more regularization should be added to the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 100\n",
    "NUM_EPOCHS = 30\n",
    "LEARNING_RATE = 0.01\n",
    "args_d = {}\n",
    "args_d[\"learning_rate\"] = [LEARNING_RATE]\n",
    "args_d[\"save_model\"] = [True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished Experiment"
     ]
    }
   ],
   "source": [
    "experiment_result_path = experiment.launch(\n",
    "    train_fn, \n",
    "    args_dict = args_d,\n",
    "    name='tinyimagenet_resnet_150_epochs',\n",
    "    description=\"Training TinyImageNet 150 epochs using hyperparameters found with differential evolution\",\n",
    "    local_logdir=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_acc1: 0.7361346604141135, train_acc3: 0.9071022858434983, train_acc5: 0.9488583110523515, loss: 0.8728083318951905"
     ]
    }
   ],
   "source": [
    "learning_rate = LEARNING_RATE\n",
    "train_results_path = hdfs.project_path() + \"Resources/tinyimagenet_train_results_\" + \"lr=\" + str(learning_rate) + \".json\"\n",
    "train_results = json.loads(hdfs.load(train_results_path))\n",
    "train_results.keys()\n",
    "print(\"train_acc1: {}, train_acc3: {}, train_acc5: {}, loss: {}\".format(train_results[\"acc\"][-1], train_results[\"top3_acc\"][-1], train_results[\"top5_acc\"][-1], train_results[\"loss\"][-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val_acc1: 0.09000000357627869, val_acc3: 0.2199999988079071, val_acc5: 0.28999999165534973, loss: 8.212908744812012"
     ]
    }
   ],
   "source": [
    "learning_rate = LEARNING_RATE\n",
    "val_results_path = hdfs.project_path() + \"Resources/tinyimagenet_val_results_\" + \"lr=\" + str(learning_rate) + \".json\"\n",
    "val_results = json.loads(hdfs.load(val_results_path))\n",
    "print(\"val_acc1: {}, val_acc3: {}, val_acc5: {}, loss: {}\".format(val_results[\"top1_acc\"], val_results[\"val_top3_acc\"], val_results[\"val_top5_acc\"], val_results[\"loss\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%local\n",
    "import json\n",
    "from hops import hdfs\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import rcParams\n",
    "LEARNING_RATE = 0.01\n",
    "best_learning_rate = LEARNING_RATE\n",
    "# Read the training history for the training run with the best hyperparameters\n",
    "results_path = hdfs.project_path() + \"Resources/tinyimagenet_train_results_\" + \"lr=\" + str(best_learning_rate) + \".json\" \n",
    "results = json.loads(hdfs.load(results_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7064212080>]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"loss\"] #loss\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Loss per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7064213400>]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"acc\"] #acc\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Top1 Accuracy per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Top1 Accuracy\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f70641d1208>]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEWCAYAAABIVsEJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xd8VvX5//HXRdgQwgp7yhDZYBiO1t2qddYFThDFPbu0dVRt/Vk7tF+1bgQRAWfFitu2biHsKSJ7hxVGCFnX749zYm9jxk3InTt38n4+Hnnkvs+8zrjPdc7nc87nmLsjIiJyoGrFOwAREUlMSiAiIlIuSiAiIlIuSiAiIlIuSiAiIlIuSiAiIlIuSiCSsMzsATN7ppLmNcbM3qyMeYmUxsxWmdmQih62POKSQMxsT8RfgZnti/h+0UFO+zdmttLMdpnZejN70MySyhinaRjD6wcz75rMzK42s7wi23aPmbWId2zRMLNvI2LON7PsiO+3uvuz7n56BcznZDNbXhExV6QwGbuZnRHRrXHYrU0U45e5XGY2xcz2h+t0u5m9Y2bdKyD2KeFxZEBEt75mlh3l+Feb2QdFuj1gZrlF9uV2Ef2HmNlcM8sysxlm1reEaZe6X5Vned29i7vPrOhhyyMuCcTdGxf+AWuA0yO6TTrIyb8KDHD3JsAA4EjgqjLGuQDIAk6t7AOemdWuzPlVhFJi/k/ktg3/tlVqcOXk7t0i9smZwBURy/C3eMdXSbYD95qZxXAe94XruAOwA3iygqa7A7ivgqZVaEKRfXkDgJk1AN4AngKaAS8Drxf3uzjQ/SrRjgdVsgjLzBqY2WNmttHM1pnZn82sTtjvZDNbbmb3hGcxK83svMJx3X25u+8qnBRQAJR1lnMZ8DDwLTCySCxdzOwNM9sa/v01ot+1ZrbUzHab2QIz62dm9cOztg4Rw00xszuKxH+nmW0GHjezVDN728wywmV6w8zaRozf0syeN7NNZrbDzKaG3Zeb2UkRw9U3s0wzO6yYdVrqegvX+cNmtjaczyNmVq+kmMtYnz8QTvPX4frabmZPFU4/7H9deLa2zcxeM7PWEf0GmNlH4bJvMrNfREy6gZlNDrfBfDMbeKCxRRn/d2epEdt4bBjzDjN7KOzX0IKr3x4R43YIz1SbFjPdL83s9+FZ7J5w2VuY2UvhdL4ssi89Hv4mdoXjDI/o19jMXjSznWa20Mxut4irAjPrGLEvrzCzq4uEMw2oD5xfwjoodh+x4KTrdeAQi/LK092zCA6839teZnaVmX0d7iNvmVn7sHuSBceEjHAfn2dmh0aM+ixwpJkNKyH25hG/obVmdreZ1TKzQQS//WPDuDeVFnfoJCDb3f/h7vuBvwLJwNFRjFs0ruvN7H0ze8LMdgC/NLPeZvZxuA62mNlzZtY4YpythdvdzP4SLtfU8Dcwz8z6lXPYIyw4ju02s4nhvnJbafFXyQQC3AP0B/oBhwPHAr+O6N8FqAu0Aa4EJphZ18KeZjbazHYDW4CeQInl5GbWExgOvAhMIkgmhf3qAG8DS4BOQEeCKxzM7BLgNwQJpwlwLsFZUDS6AHXC6d1IsB2eCOdRuBwPRQw/lSAZ9gJaA4+F3Z8HLo4Y7kxgmbsvKWW+Ja23vxGcFfYDDiVYb7cVGTcy5vIYCRwfTn8Q8CsAMzsVuBM4G2gPbAUmhv2aAR8Ar4Vx9wQ+jpjm2cA4oCnwIcHBoLKcTLAcg4HRZnZseGB8he9vl4uAt9x9ZwnTuYDgoN2JYP1/RrCNmwOrgd9FDPtFOEwLgrPgl8P9FOAPQCrQGfgZcEnhSBYU404HPgfahbH/1syOiZh2PnAXcI8VX+xb7D4SXmWeDayI9srTzJKBEUBkgrsAuBk4nWA/nwO8EPY+jWA9dyM467+Q7//edgEPAn8sYZaTgEzgEGAocBZwibvPCedZePUcWVx3bngQX2BmV0R07wPMK/zi7gXAwrB7eRwHfAW0BP4edruLYB0MCKdb2oH8HIIruaYEv42HDnRYM2sI/DOcfzPgXeDUMiN397j+AauAE4t0Ww8cH/H9TGBp+PlkIBuoH9F/GvCrYqbdi+CyNrWU+f8B+DL83BVw4LDw+3FhLLWKGe+/wFXFdK8fTqNDRLcpwB0R8e8F6pQS03BgY0RMOUByMcN1IfhRNAi//wu4sYRplrjegNrhPNpH9DsOWHIAMV8N5AI7I/4WRfTfBIyK+P7zwv4EP+57I/o1JbhybAOMBr4oYZ4PAP+K+D4Y2FkB++SXwMXFLN8HRbZxWpF1eXP4+RhgeUS/BcAZEetyeZF5/SLi+2PA6xHfzyvcP4uJ0wiKXg8Nv28Ajonof33hvMKYviky/j3A4xHr8plwmnPD9d44XM42Ue4jy4uLs8jvYF+4bzhB8ugd0f/fwEUR3+uE+1RrgoPZIoKDf61ipnsH0BDYSHDC2ZfgKgGChPq9/TdcvreLbtuI/n3D5U4CfgxkAGeH/f4IjC8y/KsEyfRA96vrgcVljHcx8EnE963A8PDzX4B/RvQbCmw90GHD9busyHznlrVMVe4KxMyMYMOtjui8muDMtFCGu2cX6d+OItx9KUGx1N+L9ouY1yUEBzDcfSXBGV7hVUhHYKUHZxhFdQynXR6b3D03Io5kMxtnZmvMbBfwHsHZSOF8trj77qITcfdVBGdpZ5lZKsHZ/ZRS5lvSemtH8GNdFBZ/7CQ4G2lVUswl+K+7N434K3pGtraYeRP+/257e3Cmvotgm5e1niOLHLIIDno/YEHRXWHxSkVdpZQ074+BpLBIYCDQluBKtiSbIz7vK+Z7ZPHF7WERTybBGXh9oKWZ1SL43USu48jPnYEuhds33Ma3huN8x4Mjx50EZ8B1InpFs49E44/u3pTgSiCf7xcvdwaeiJh+BpBHcNXzNkEx1ZPAJjP7R2SxThh7FnA/P7wK6UywnjIipv13gsRULHdf6O6b3D3f3T8mSOznhr33EJQ6RGoC/OA3GqXI7VRY5PmKmW0IjwdP8L/jQXGi+g2UMWw7YF1pcRWnyiWQcAfeRLDRC3UiuBIo1NLM6hfpv6GESdYmuOwtznHhuL8Py0Y3EVwyXhz+INcS/OiKW09rS5huDsFZU8OIbkXvYinaBPJtBD+SIR5U/v+E4EywcD6tiv5YIkwgOEMZAXzk7ltKGA5KXm8bCX6o3SIO/inuHlmOXRHNNncsZt6E/7/b3hbUFTQh2OYlrecD4u53+/+KV24+2OmVMS/nf8WLlwBToki+ZbKgvusGguKipgRFXPsAC09yNhPsR4Ui1/dagqv4yASf7O5nFxP/m+G0rozoXNY+ckD7R3iy9kvgETOrGxHjqCIxNnD3WR74m7sPIijeHgDcVMyknwzXQWTxy1qCg36ziOk2cffBBxC787/f5KJw/gCEx4e+YffyKDr/vxKULPQOjwdXR8w7Vjby/X0Hvr//FKvKJZDQZOBuCyoTWxGUAb8Q0b8OcKeZ1TWz4wkqtQrrJq60oFLawgqiXxOUjRfnMoJinz4ElXkDCXaM5sAJwKcEZxX3WVA52sDMjgzHfQa4zYIKXjOznmbWIfwhLwAusqDi7wzgiDKWN5ngbGCnmbUkuBwHvvuhfQw8amYp4TL/OGLcVwgq764hOGiVptj1Fh7cxgF/t6DC3iyocD2p1KkduBvNrG24jLcR1O1AsL2vtODWy/oExSkfufsmgrPc7mZ2TRh3E4vhfe0V6HmCeo2RlL1dopVMcHKSQVCXdS/BmXWhl4DfhftJJ4J9otCnAGZ2swU3AdQ2s/5mNpji/Y6gjg+AKPaRzZR+ovMDYaLaRVCcBMGZ9h0WVo6bWTMzOyf8PNzM0iy4S2kvwYnaD0oG3D0nXC+Rsa8kKD56MLzar2VmPcyssNJ7M9Axoi4JMzs7XI9mZkcA1xHUOQG8T3DzxtUW3AhySxjTp9EuexmSCY47u8ysSzj9WPs30NTMLg/3jQuJok6nqiaQu4DFBBl9LkGl4oMR/VcRnA1tItipR7v7irDfceG4ewg2+KvA74vOINzRzwH+L7xULfxbTlAMdFn4ozmVIKmsI7jl+GwAd59IUKn4CsHGfoXgrBCCcs0LCIoYziJIUqX5C8El6jaCnXB6kf4jCQ7+34TL/N2BISzaepPgEnRaGfNZRcnr7WaCK4F0grOfdyj77rWiCu9kifzrF9F/CsGO+g1Bkn0wXIZ/Af8vjH8DwRXbJWG/HQSJbgTBTRFfU467XSqbu39LEOtud59RQZN9k+Bk4ltgBUH5dkZE/zsI9rnVBEU+LwH7w3gK9+Ujw/4ZBHfTFXvAd/cPiagoDpW2j8wj2H6rw2Ki5lEu018ITsTquPtk4FHgtbDoZi7BtofgtzWeoP5kRbgMxRZNE1yVF63EHxlOYynB7cpT+V8R1jsEv40tZlZYjHNJ2G03wW/lbnefCuDu+wjqZa8O4xkBnOXueVEuc1nuIDiO7SI4rrxcQdMtUVj8dzZBseYOgn3lA8L9pyQWVpYkDDM7GXjU3Q/6AaTqwszuB1q5+xWlDBPX9RYWD57r7hV1llblmdmLBBWkf4jT/G8BTnb3n8Zj/pLYzGwhcI+7l5jAquoViETJgsrzUQQPNUkVYcET1qcBz1XiPDuGRT21zKwPQR2BWleQqJjZ8WHxfx0zu5agnrKk4n9ACSShmdn1BJfZL1dgMYkcJDN7kODuuHvdfX1Zw1egegTFLbsJimWmUMozUCJF9CeoNthBcAPF2e6+vbQREq4IS0REqgZdgYiISLkkVMNdAC1btvQuXbrEOwwRkYQya9asre6eWpHTTLgE0qVLF9LT0+MdhohIQjGz1WUPdWBUhCUiIuWiBCIiIuWiBCIiIuWiBCIiIuWiBCIiIuWiBCIiIuWiBCIiIuWiBCIiUsVt2Z3NX979mm8z9sQ7lO9JuAcJRURqimWbd/PMJyv455wN5BYU0DqlPt1So35nV8wpgYiIVCHuzhffbuOpT1bwn68zqF+nFucP6cCYow+ha8tG8Q7ve5RARESqgNz8At6av5GnPl7B4o27aNm4Lree1JOLh3emeaO6ZU8gDpRARETiaFd2LlNmrOG5z1axMTOb7q0a86dz+nHmwPbUr5MU7/BKpQQiIhIHefkFPPnxCh7/z7fs2Z/HEYe04I9n9+XYnq2oVcviHV5UlEBERCrZ6m17uWXqXGav2clPerfmxhN60Ld9SrzDOmBKICIilcTdmTJzLff9azFJtYy/jxjImQPbxzusclMCERGpBBm793P7a/P5YMkWjuzWgr+cN4B2TRvEO6yDogQiIhJj7y/ezG2vzmf3/jzuPK03o4/skjD1HKVRAhERiZE9+/O4783FTE1fS++2TZg8YiA9WyfHO6wKowQiIhIDs1Zv55ap81i7I4trju3GLSf2pG7t6tV6lBKIiEgFyssv4OEPvuEf/1lOu6YNeOmqIxjSpXm8w4oJJRARkQqyMyuHGybP4ZNvtnLe4R246/TeJNevE++wYkYJRESkAizbvJsrn09n485sHjynP+cP6RjvkGJOCURE5CC9t2gTt0ydS8N6tZk8djiHd24W75AqhRKIiEg5FRQ4j3y0nIc+WMaADik8eUkabVLqxzusSqMEIiJSDnv35/GLl+bxzqJN/HxQe+7/eb8q3/hhRVMCERE5QGu2ZTF2YjrLNu/mjp8dxpiju2KW+A8GHiglEBGRA/D58q1c++Js3GHC5UP5UY/UeIcUN0ogIiJRcHcmfL6K+95awiEtG/H0pWl0qWJvCKxsSiAiImXIL3DunraQF75cw0m9W/PQBQNpXE+Hz5g+V29mJ5vZ12a23MxuK6Z/JzP7t5nNMbP5ZnZqLOMRETlQOXkF3DRlDi98uYarjjmEJy8+XMkjFLO1YGZJwGPAScA6YKaZTXP3xRGD3QG85O6Pm1lvYDrQJVYxiYgciKycPK55YTb/XZbB7af04qpjusU7pCollml0KLDc3VcAmNkU4EwgMoE40CT8nAJsiGE8IiJRy8zK5fIJM5mzZgcP/LwfI4Z2indIVU4sE0h7YG3E93XAsCLD/B54z8xuABoBJ8YwHhGRqGzZnc2lz85gRcZeHrtwMKf0axvvkKqkeLctPBIY7+4dgFOBiWb2g5jMbKyZpZtZekZGRqUHKSI1x9rtWZz3xBes2Z7Fs6PSlDxKEcsEsh6IbE2sQ9gt0hjgJQB3/wKoD7QsOiF3f8rd09w9LTW15t5zLSKx9fWm3Zzz+OfszMrlhSuG1ehnPKIRywQyE+hhZl3NrC4wAphWZJg1wAkAZnYYQQLRJYaIVLrZa3Zw/pNfAPDSVUcwuFPNaBDxYMSsDsTd88zseuBdIAkY5+6LzOxeIN3dpwG/AJ42s1sIKtRHubvHKiYRkeJ8+s1Wxk5Mp2Xjeky6YhgdmzeMd0gJIaY3M7v7dIJbcyO73RXxeTFwVCxjEBEpzdsLNnLTlLkcktqI5y8fSqsmNac13YOlp2FEpMZ6c94Gbpoyh4Edm/LcqKGkNKy+bw+MBSUQEamRpi/YyM1T55LWuTnPjR5CIz1dfsDifRuviEile2fhJm6cPIdBHZsyTsmj3JRARKRG+WDxZm6YPJt+HVJ4bvQQtWt1EJRARKTG+PfSLVw7aTa92zZhwuVDSa6vOo+DoQQiIjXCf5dlcNULs+jZpjHPXz6MJkoeB00JRESqvc+Wb2Xs8+l0T23MC2OG6W6rCqIEIiLV2hffbmPMhJl0bdmIF64YRtOGdeMdUrWhBCIi1daMldu5fPxMOjVvyKQrhtG8kZJHRVICEZFqKX3VdkY9N4N2Tesz6YrhtGhcL94hVTtKICJS7cxdu5NRz82kTZP6TL5yOKnJSh6xoAQiItXKmm1ZjBk/k+aN6vLilcPVtlUMKYGISLWRuS+X0eNnkFfgjB89hDYpSh6xpAQiItVCbn4B106axZrtWTx5yeEckto43iFVe3qGX0QSnrtzx+sL+Wz5Nv563gCGH9Ii3iHVCLoCEZGE9+THK5iavpYbju/OOYd3iHc4NYYSiIgktLcXbOSBt5dy+oB23HpSz3iHU6MogYhIwpq7dic3T53L4E5N+fO5/TGzeIdUoyiBiEhCWrcjiysmpNOqST2evjSN+nWS4h1SjaNKdBFJOLuyc7l8/Ez25+UzZewwPWUeJ7oCEZGEkpdfwPUvzmFFxl6euPhwurdKjndINZauQEQkYbg7d09bxMfLMvjTOf04qnvLeIdUo+kKREQSxrOfrmTSV2u4+phuXDCkU7zDqfGUQEQkIfxr/gb+OH0Jp/Zrw69/emi8wxGUQEQkAXz6zVZumTqXIZ2b87fzB1Krlm7XrQqUQESkSpu/bidjJ6bTLbUxT1+m23WrEiUQEamyVmTsYdRzQdPsEy4fSkoDvcu8KlECEZEqafOubC55dgYGTBwzjNZ6r0eVowQiIlVOZlYulz47g51ZOYwfPZSuLRvFOyQphp4DEZEqJTs3nyuen8nKrXt5bvQQ+nVIiXdIUgIlEBGpMoKnzGeTvnoHj44crAcFqzgVYYlIleDu3P7aAj5YsoV7z+jDz/q3jXdIUgYlEBGpEv70zte8PGsdN53Qg0uO6BLvcCQKSiAiEnfPfLKCJ/77LRcN68TNJ/aIdzgSpTITiJk1rYxARKRmem32Ov7wVtBEyb1n9tVLoRJINFcgs8xsspn9JObRiEiN8u6iTfzqlfkc2a0FD10wkCQ1UZJQokkgPYDngSvN7Bszu9fMusU4LhGp5j5bvpUbXpxDv/YpPHVpGvVqq4mSRFNmAnH3And/293PA64ExgBzzexDMxta2rhmdrKZfW1my83sthKGOd/MFpvZIjN7sVxLISIJZfaaHVz5fDpdWzZi/OghNK6nJwoSUZlbLawDuQi4FNgB3AK8DhwOTAW6ljBeEvAYcBKwDphpZtPcfXHEMD2A24Gj3H2HmbU6uMURkapuycZdjBo3g9TkekwcM5SmDevGOyQpp2jS/kzgReB8d18d0f1LM3u6lPGGAsvdfQWAmU0BzgQWRwxzJfCYu+8AcPctBxK8iCSWlVv3csmzM2hYtzYvjBlGK7VvldCiSSA93d2L6+Hu95cyXntgbcT3dcCwotMGMLPPgCTg9+7+TtEJmdlYYCxAp056C5lIItqwcx8XP/MVBe68cMUwOjZvGO+Q5CBFU4n+duStvGbWzMzeqqD51yaopD8WGAk8Xdxtw+7+lLunuXtaampqBc1aRCrLtj37ufjZr9i1L5fnLx9K91bJ8Q5JKkA0CaSNu+8s/BIWN7WLYrz1QMeI7x3CbpHWAdPcPdfdVwLLCBKKiFQTmftyuXTcDNbv2Mezo4bQt70aR6wuokkg+WbWofCLmUVbhjQT6GFmXc2sLjACmFZkmH8SXH1gZi0JirRWRDl9Eani9uXkM2b8TJZt3s0TlxzO0K7N4x2SVKBo6kDuAj4zs48AIzjgX1PWSO6eZ2bXA+8S1G+Mc/dFZnYvkO7u08J+PzGzxUA+8Ct331a+RRGRqiQnr4CrXpjF7DU7eGTkYI47VDdZVjdWQv349wcyaw0cEX79PJ53S6WlpXl6enq8Zi8iUcjLL+DGKXOYvmATfzqnHxcM0c0v8WZms9w9rSKnGW1jitnAGmAL0N3MjqzIIESk+sjJK+D6F4PkccfPDlPyqMaieZDwcuAXBLflLgCGAF8S1l2IiBTKzs3n2kmz+WjpFu48rTdjji72OWOpJqK5ArkFSANWufuPCJ5AVz2FiHzPvpx8rnw+nY+WbuG+s/oqedQA0VSiZ7v7PjPDzOqGFeGHxjwyEUkYe/bnMWb8TGas2s6D5/bn/LSOZY8kCS+aBLIxfLjvTeBdM9tO8PyGiAi7snMZNW4G89Zl8vAFAzlzYPt4hySVpMwE4u5nhB/vNLMTgBSgop5EF5EEtjMrh0vHzWDJxl08OnIQp/TTe8xrklITSNii7nx37wPg7h9WSlQiUuVt27Ofi575ihUZe3ni4sM54bDW8Q5JKlmplejung+sMDNdk4rId7bsyuaCp75k1ba9PHNZmpJHDRVNHUhjYImZfQHsLezo7j+PWVQiUmVt2LmPC5/+ki279zN+9FCGH9Ii3iFJnESTQP4Q8yhEJCGs3Z7FyKe/JDMrl4ljhnJ4Z7VtVZNFU4mueg8RYcnGXVw2bgb78wqYdOUw+nf4wZsXpIaJ5kn03UBhg1m1CRpG3O/uTWIZmIhUHTNWbmfMhJk0qlubl68+gp6t9T4Pie4K5Ls9xcxqAT8HBsYyKBGpOt5fvJnrX5xN+2YNeP7yoXRopjcJSiDaxhQBcPcCd38F+FmM4hGRKuSl9LVc/cIserVJ5pWrj1TykO+JpgjrjIivtQjaxcqJWUQiEnfuzpMfr+CBt5fyox4teeLiw2lUL5p7bqQmiWaPOC/icx6wCjgzJtGISNwVFDj/7+0lPP3JSk4f0I6/njeAurUPqLBCaoho6kAuqYxARCT+cvML+M0r83ltznouO6Izd5/eh1q1LN5hSRVV5mmFmT0bNqZY+L2ZmT0d27BEpLLty8ln7PPpvDZnPb84qSe/P0PJQ0oXTRHWYHffWfjF3XeY2eExjElEKtnOrBwuHz+TuWt3cv/Z/bhwmN4iKGWLJoHUMrMUd8+E4AoEqBPbsESksqzI2MNVE2exelsW/7hoMCf3VYu6Ep1oEsjDwBdmNjX8fgHwYOxCEpHKMn3BRn79ynzqJBkTLh/KEd3UrpVEL5pK9OfMbBZwfNhphLvPj21YIhJLOXkFPPD2UsZ9tpJBnZry2IWDade0QbzDkgQTzXMgQ4AlhUnDzJLNLM3d02MenYhUuI2Z+7hu0mxmr9nJqCO78NtTD9NtulIu0RRhPQVEVprvBZ4s0k1EEsAn32Rw05S57M/N59ELB3Fa/3bxDkkSWFSV6O5eUPjF3QvMTJXoIgmkoMB55KPlPPzhMnq0asw/Ljqc7q0axzssSXDRJJCVZnYNwZWIA9cQPI0uIglg+94cbp46l4+XZXD2oPb88ey+NKyrZknk4EWzF10FPAbcR5BA/g1cEcugRKRizF6zg+smzWbbnhzuP7sfI4d2xEwPB0rFiOYurM3AuZHdzGwQsCVWQYnIwXF3xn++ivunL6F1k/q8es2R9OuQEu+wpJqJ+jrWzHoCI4ELgX3onSAiVdKu7Fx+88p83l64iRN6teJv5w8kpaGqLaXilZpAzKwDQdIYSdBuVkdgmLsvr4TYROQALVyfyXUvzmbdjn3cfkovrvzRIWrPSmKmxARiZp8AqcBU4CJ3X2JmK5U8RKoed2fSV2u4983FNG9Ul6ljh5PWpXm8w5JqrrQrkEygE5ACFL7W1kseXETiYc/+PG5/bQFvztvAj3um8tD5A2jRuF68w5IaoMQE4u6nhQ0nngs8YGadgGZmNtjdZ1dahCJSoqWbdnHtC7NZtW0vv/rpoVxzTDcVWUmlKbUOxN13AE8DT5tZW4KGFB83szbu3rkyAhSRH3J3Xk5fx51vLKRJgzpMumK4GkKUShf1XVjuvpGgZd6HzeyQ2IUkIqXJysnjjn8u5LXZ6zmqewsevmAQqckqspLKV67HUd19RUUHIiJlW7Z5N9dNms3yjD3cfGIPbji+B0kqspI4iWkTnGZ2spl9bWbLzey2UoY7x8zczNJiGY9IonJ3Js9YwxmPfsqOrBwmXj6Mm0/sqeQhcRWzBnHMLImgCZSTgHXATDOb5u6LiwyXDNwEfBWrWEQS2a7sXH772gL+NX8jP+rRkr+eP4BWyfXjHZZIqc+BNCBoONGBfwDnAT8HlgJ/dPe9ZUx7KLC8sLjLzKYAZwKLiwx3H/An4FflWQCR6mze2p3cMHkO63fu011WUuWUVoT1HNAZ6AW8CRwFPAI0ILiyKEt7YG3E93Vht++Y2WCgo7u/VdqEzGysmaWbWXpGRkYUsxZJbO7OM5+s4NwnPicvv4CpY4dz3XHdlTykSimtCOswdx9hZrWAjcBP3d3N7D/A3IOdcTjdvwGjyhrW3Z8iaE6etLQ0Pcwo1dr2vTn88uV5fLR0Cz/p3ZoHz+1P04Z14x2WyA+UlkAcvnuB1DvuXvjdo2wOej1B21mFOoTdCiUDfYGDxCwsAAAToUlEQVT/hNNrA0wzszP0ulypqb5asY2bpsxl+94c7jmjD5ce0VnNr0uVVVoCmWtmjd19j7tfVtjRzLoCe6KY9kygRzj8emAEQUu+ALh7JtAyYrr/AX6p5CE1UX6B8+hHy/n7h8vo3KIRr112JH3bq/l1qdpKa8pkVAndV5rZMWVN2N3zzOx64F0gCRjn7ovM7F4g3d2nlTNmkWpl865sbp4yly9WbOPsQe2576y+NK6nNwZK1VfmXmpm9QjeSng0QbHWpwT1EXlljevu04HpRbrdVcKwx5Ydrkj18t9lGdw6dS5ZOfn8+dz+nHt4BxVZScKI5jRnArCfoE0sCIqhJhAUSYlIOeTmF/C395fx+H++5dDWyTx64SB6tE4ue0SRKiSaBNLf3XtHfH/fzIo+yyEiUVq/cx83Tp7DrNU7GDm0I3ed1ocGdZPiHZbIAYsmgcwzsyHuPhPAzA4H5sQ2LJHq6f3Fm/nly/PIyy/g7yMGcubA9mWPJFJFRZNA+gFfmVlhA4pdgSVmNofgrt7BMYtOpJrIySvgT+8s5dlPV9KnXRMevXAwXVs2indYIgclmgRyZsyjEKnG1mzL4vrJs5m/LpNRR3bh9lN7Ua+2iqwk8ZWZQNz9WzPrA/wo7PSJuy+KbVgi1cP0BRv5zSvzMYMnLj6ck/u2iXdIIhWmzObcw2c5XiZ4P3on4CUzuzbWgYkkMnfn0Y++4dpJs+nWqjFv3fgjJQ+pdqIpwhoLDHX3PQBmdj/wOUELvSJSRF5+AXe+sYjJM9Zw1sB2PHjuAOrWjumrd0TiIpoEYkBOxPfcsJuIFJGVk8f1L87ho6VbuPbYbvzqp4fqwUCptkp7H0htd88DJhLchfVq2OtsggcJRSTC1j37GTN+JgvWZ3LfWX25ZHjneIckElOlXYHMAAa7+4NhQ4dHh92vLnwmREQCK7fu5bJxM9iyO5snL0njpN6t4x2SSMyVlkC+u+529xkECUVEipi9Zgdjxs/EzJh85XAGdWoW75BEKkVpCSTVzG4tqae7/y0G8YgklPcWbeKGyXNok1Kf8aOH6uFAqVFKSyBJQGNUYS5SrIlfrOLuaYvo16Epz16WRsvG9eIdkkilKi2BbHT3eystEpEEUVDgPPju1zzx32858bBW/N/IQTSsq/d3SM0TVR2IiATyC5zbXp3Py7PWcdGwTtxzRh9qJ+kZD6mZSksgJ1RaFCIJIC+/gFtfmse0eRu46YQe3HxiDz3jITVaaa+03V6ZgYhUZTl5Bdw0ZQ5vL9zEr08+lGuP7R7vkETiTgW3ImXIzs3nukmz+XDpFu48rTdjju4a75BEqgQlEJFS7MvJZ+zEdD75ZqueLhcpQglEpARZOXmMGZ/Olyu38eA5/Tl/SMd4hyRSpSiBiBRjd3Yul4+fyazVO3jo/IGcNUivnhUpSglEpIjMrFwufW4Gi9Zn8sjIwfysf9t4hyRSJSmBiETYsTeHi5/9imWbd/OPiwbzkz56CZRISZRAREIZu/dzybNfsWLrXp66NI3jDm0V75BEqjQlEBFg0YZMbnhxDhsy9/HcqCEc1b1lvEMSqfKUQKRGyy9wnv5kBX9972uaNazLxDHDGNKlebzDEkkISiBSY63bkcWtL81jxsrtnNK3Dfef3Y9mjerGOyyRhKEEIjWOu/P6nPXc/cYiHPjLeQM4Z3B7tWslcoCUQKRG2ZmVw+9eX8hbCzaS1rkZD10wkI7NG8Y7LJGEpAQiNcYn32Twy5fnsW1PDr/66aFcfUw3kmrpqkOkvJRApNrLzs3ngbeXMv7zVXRv1ZhnLxtC3/Yp8Q5LJOEpgUi1tmTjLm6cPIdvtuxh1JFduO2UXtSvkxTvsESqBSUQqbbemLue37w6n+T6dZhw+VCO6Zka75BEqhUlEKl2cvMLuH/6Ep77bBVDuzTn0YsG0Sq5frzDEql2lECkWtmyO5vrJ81hxqrtjD6qC7899TDq6J3lIjER01+WmZ1sZl+b2XIzu62Y/rea2WIzm29mH5qZ3tYj5TZr9Q5Of+RT5q/fycMXDOTu0/soeYjEUMx+XWaWBDwGnAL0BkaaWe8ig80B0ty9P/AK8GCs4pHqy9154cvVjHjqC+rVTuK1a47S+ztEKkEsi7CGAsvdfQWAmU0BzgQWFw7g7v+OGP5L4OIYxiPVUHZuPnf+cyEvz1rHsYem8vcLBpHSsE68wxKpEWKZQNoDayO+rwOGlTL8GODtGMYj1cy6HVlc88JsFqzP5MYTenDzCT2opQcDRSpNlahEN7OLgTTgmBL6jwXGAnTq1KkSI5Oq6tNvtnLD5Nnk5TvPXJrGib1bxzskkRonljWM64GOEd87hN2+x8xOBH4HnOHu+4ubkLs/5e5p7p6Wmqp7+Wu6CZ+v4tJxX5GaXI9pNxyt5CESJ7G8ApkJ9DCzrgSJYwRwYeQAZjYIeBI42d23xDAWqQZy8wu4983FTPxyNSce1pq/jxhIo3pV4iJapEaK2a/P3fPM7HrgXSAJGOfui8zsXiDd3acBfwYaAy+HTWmvcfczYhWTJK7MfblcN2k2ny7fylU/PoRfn9xLDSGKxFlMT9/cfTowvUi3uyI+nxjL+Uv1sGrrXsZMmMma7Vk8eG5/zk/rWPZIIhJzuv6XKu3LFdu4+oVZAEwcM4zhh7SIc0QiUkgJRKqsl2au5Xf/XECn5g0ZN2oInVs0indIIhJBCUSqnPwC50/vLOWpj1fwox4tefTCwaQ00MOBIlWNEohUKXv353HTlLl8sGQzlwzvzN2n96a22rMSqZKUQKTKWLs9i7ETZ/H1pl3cc0YfLjuyS7xDEpFSKIFI3OXlFzD+81X89b1l1K5lPDdaL38SSQRKIBJXizZkcturC1iwPpMTerXivrP60q5pg3iHJSJRUAKRuNiXk8/DHy7jmU9W0qxhHR69cBA/69eW8IFSEUkASiBS6T5bvpXfvr6A1duyOD+tA7899TCaNqwb77BE5AApgUil2bE3hz9OX8Irs9bRpUVDXrxyGEd2axnvsESknJRAJObcnTfnb+SeaYvI3JfLtcd248YTelC/TlK8QxORg6AEIjG1KTOb376+gI+WbmFAhxQmjhlG73ZN4h2WiFQAJRCJCXfnlVnruPdfi8nNL+COnx3G6KO6qgVdkWpECUQq3OZd2dz+WnDVMaRLM/587gC6tFQ7ViLVjRKIVBh35/U56/n9tEXk5Bdw52m9GX1kF72nXKSaUgKRCrFlV1DX8cGSLaR1bsafzxtAV111iFRrSiByUNydN+Zu4O5pi8jOzVddh0gNogQi5bZldzZ3vL6Q9xZvZlCnpvzlvAF0S20c77BEpJIogcgBy9i9n1dnr+OJ/35LVk4+vz21F2OOPkRXHSI1jBKIRCW/wPl4WQZTZq7hwyVbyCtwhh/SnD+c1Y/urXTVIVITKYFIqdZuz+Ll9LW8PGsdGzOzad6oLqOP6sIFQzrSvVVyvMMTkThSApEf2J+Xz3uLNvNS+lo+Xb4VgB/3SOWu03pzwmGtqVtbbwgUESUQCRUUOLPX7OBf8zfyxtz17MjKpX3TBtx0Qg/OS+tIe72jQ0SKUAKpwQoKnPTVO5i+YCPvLNzEpl3Z1E2qxYm9WzFiSCeO6t5SFeMiUiIlkBomv8BJX7Wd6Qs28vbCTWzZvZ+6tWtxTM9UbuvXixMOa0Vy/TrxDlNEEoASSA2Qk1fArMIrjUWbyNi9n3q1a3Hcoa04pV8bTjisNY3raVcQkQOjo0Y1k5WTx5KNu1m0IZNF63excEMmyzbvJjffqV+nFsf3asUpfdtyfK9WNFLSEJGDoCNIDBQUOJt3Z7Ny615Wbc1i1ba9rNmWRb06tWib0oC2KfXDvwa0SalPi0Z1D6jBQXdnf14Bu7JzWb5lz3eJYtGGXazI2EOBB8M1b1SXPu2aMOboQxjYMYUf90ylYV1tchGpGDqalCK/wMnNLyAnv4C8/PBzXgF5Bf/7vDs7j9Xb9rJy215WhQlj9fa9ZOcWfDedurVr0bFZA3LyC9iUuZHcfP/efOom1aJ1Sj3aNmlA26b1adqgDntz8tm7P4894d/e/Xns3Z/P7uxc9ubkk1/w/Wm0S6lP73YpnNa/LX3apdC3fRPaNKmPmSrBRSQ2anwCcXc2ZGazYN1O5q/LZMH6TBauz2Tnvlzcyx6/UN2kWnRq0ZAuLRryox4t6dKyEV1bNqJLy0a0bVL/uyuMggJn294cNmVmsyFz3/f+b9yZzew1O8jMyqVRvdo0rlf7u/+tk+vTqF5tkuvXplG9JBrXq0Pjekl0btGIPu2a0KJxvRitIRGR4tW4BLJlVzbz12Uyf30mC9btZMH6TLbuyQGgdi3j0DbJ/LRPG1KT61EnqRa1k4y6SbWo892ffe9zo3q16dS8Ie2aNojqltdatYzU5HqkJtejX4eUWC+uiEjM1JgEMnXmGh56/xs27coGoJZBj1bJHHdoK/p3SKFfh6b0apNM/TpJcY5URCQx1JgEkppcjyO6taBf+xT6d0ihd7smqlAWETkINeYIenyv1hzfq3W8wxARqTbUKp6IiJSLEoiIiJSLEoiIiJRLTBOImZ1sZl+b2XIzu62Y/vXMbGrY/ysz6xLLeEREpOLELIGYWRLwGHAK0BsYaWa9iww2Btjh7t2Bh4A/xSoeERGpWLG8AhkKLHf3Fe6eA0wBziwyzJnAhPDzK8AJprY3REQSQiwTSHtgbcT3dWG3Yodx9zwgE2hRdEJmNtbM0s0sPSMjI0bhiojIgUiISnR3f8rd09w9LTU1Nd7hiIgIsX2QcD3QMeJ7h7BbccOsM7PaQAqwrbSJzpo1a6uZrS7SuSWw9eDCrVKq2/JA9Vum6rY8UP2WqbotDxzcMnWuyEAgtglkJtDDzLoSJIoRwIVFhpkGXAZ8AZwLfOReehu47v6DSxAzS3f3tAqJugqobssD1W+ZqtvyQPVbpuq2PFD1lilmCcTd88zseuBdIAkY5+6LzOxeIN3dpwHPAhPNbDmwnSDJiIhIAohpW1juPh2YXqTbXRGfs4HzYhmDiIjERkJUokfhqXgHUMGq2/JA9Vum6rY8UP2WqbotD1SxZbIyqhxERESKVV2uQEREpJIpgYiISLkkdAIpq7HGRGRmq8xsgZnNNbP0eMdTHmY2zsy2mNnCiG7Nzex9M/sm/N8snjEeiBKW5/dmtj7cTnPN7NR4xnggzKyjmf3bzBab2SIzuynsnsjbqKRlSsjtZGb1zWyGmc0Ll+eesHvXsOHZ5WFDtHXjGmei1oGEjTUuA04iaCZlJjDS3RfHNbCDZGargDR3T9gHoMzsx8Ae4Hl37xt2exDY7u4PhMm+mbv/Jp5xRquE5fk9sMfd/xLP2MrDzNoCbd19tpklA7OAs4BRJO42KmmZzicBt1PYJmAjd99jZnWAT4GbgFuB19x9ipk9Acxz98fjFWciX4FE01ijxIG7f0zwXE+kyIYzJxD8uBNCCcuTsNx9o7vPDj/vBpYQtEuXyNuopGVKSB7YE36tE/45cDxBw7NQBbZRIieQaBprTEQOvGdms8xsbLyDqUCt3X1j+HkTUB1eUH+9mc0Pi7gSprgnUvgOnkHAV1STbVRkmSBBt5OZJZnZXGAL8D7wLbAzbHgWqsAxL5ETSHV1tLsPJniPynVh8Um1EjZXk5hlp//zONANGAhsBP4a33AOnJk1Bl4Fbnb3XZH9EnUbFbNMCbud3D3f3QcStCM4FOgV55B+IJETSDSNNSYcd18f/t8CvE6w41QHm8Ny6sLy6i1xjueguPvm8AdeADxNgm2nsFz9VWCSu78Wdk7obVTcMiX6dgJw953Av4EjgKZhw7NQBY55iZxAvmusMbwTYQRB44wJy8wahRWAmFkj4CfAwtLHShiFDWcS/n8jjrEctMIDbehsEmg7hRW0zwJL3P1vEb0SdhuVtEyJup3MLNXMmoafGxDcLLSEIJGcGw4W922UsHdhAYS35D3M/xpr/GOcQzooZnYIwVUHBO2UvZiIy2Rmk4FjCZqe3gzcDfwTeAnoBKwGznf3hKiYLmF5jiUoFnFgFXBVRP1BlWZmRwOfAAuAgrDzbwnqDBJ1G5W0TCNJwO1kZv0JKsmTCE70X3L3e8NjxBSgOTAHuNjd98ctzkROICIiEj+JXIQlIiJxpAQiIiLlogQiIiLlogQiIiLlogQiIiLlogQiUoSZ5Ue03jq3Ilt6NrMuka36iiSymL4TXSRB7QubkBCRUugKRCRK4btaHgzf1zLDzLqH3buY2Udhg30fmlmnsHtrM3s9fKfDPDM7MpxUkpk9Hb7n4b3wSWORhKMEIvJDDYoUYV0Q0S/T3fsBjxK0ggDwCDDB3fsDk4D/C7v/H/Bfdx8ADAYWhd17AI+5ex9gJ3BOjJdHJCb0JLpIEWa2x90bF9N9FXC8u68IG+7b5O4tzGwrwcuMcsPuG929pZllAB0im5oImxp/3917hN9/A9Rx9z/EfslEKpauQEQOjJfw+UBEtl2Uj+oiJUEpgYgcmAsi/n8Rfv6coDVogIsIGvUD+BC4Br57OVBKZQUpUhl05iPyQw3CN8EVesfdC2/lbWZm8wmuIkaG3W4AnjOzXwEZwOiw+03AU2Y2huBK4xqClxqJVAuqAxGJUlgHkubuW+Mdi0hVoCIsEREpF12BiIhIuegKREREykUJREREykUJREREykUJREREykUJREREyuX/A9F4JZXnZMuYAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"top3_acc\"] #acc\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Top3 Accuracy per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Top3 Accuracy\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f70641443c8>]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "y = results[\"top5_acc\"] #acc\n",
    "x = list(range(1, len(y)+1))#epoch\n",
    "plt.title(\"Top5 Accuracy per Epoch - TinyImageNet ResNet50 Training\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Top5 Accuracy\")\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Model and Evaluate on Validation Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path_hdfs = hdfs.project_path() + \"Resources/\" + MODEL_NAME"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In future releases of Tensorflow, Keras will be able to read directly from HDFS, but currently it is not supported. To get around this we can download the hdf5 model in the local file system and load it from there using keras function load_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "local_path = hdfs.copy_to_local(model_path_hdfs, \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "def top3_acc(x, y):\n",
    "    return metrics.top_k_categorical_accuracy(x, y, k=3)\n",
    "    \n",
    "def top5_acc(x, y):\n",
    "    return metrics.top_k_categorical_accuracy(x, y, k=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = load_model(MODEL_NAME)\n",
    "model.compile(optimizer=tf.train.AdamOptimizer(LEARNING_RATE), loss='categorical_crossentropy',  \n",
    "                  metrics=['accuracy', metrics.mae,top3_acc,top5_acc])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluate on Validation Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We have 10 000 Test examples, we can evaluate in batches of 100 to speed up the process\n",
    "BATCH_SIZE = 100\n",
    "NUM_EPOCHS = 1\n",
    "# get dataset path from the featurestore\n",
    "val_dataset_path = featurestore.get_training_dataset_path(VAL_DATASET)\n",
    "val_dataset = create_tf_dataset(VAL_DATASET, SHUFFLE_BUFFER_SIZE, BATCH_SIZE, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "1/1 [==============================] - 26s 26s/step"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(val_dataset, verbose=1, steps=1)\n",
    "val_loss = score[0]\n",
    "val_top1_acc = score[1]\n",
    "val_mae = score[2]\n",
    "val_top3_acc = score[3]\n",
    "val_top5_acc = score[4]\n",
    "validation_results = {\n",
    "    \"loss\": val_loss,\n",
    "    \"top1_acc\": val_top1_acc,\n",
    "    \"mae\": val_mae,\n",
    "    \"val_top3_acc\": val_top3_acc,\n",
    "    \"val_top5_acc\": val_top5_acc\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'loss': 7.0366740226745605, 'top1_acc': 0.15000000596046448, 'mae': 0.00865943543612957, 'val_top3_acc': 0.3100000023841858, 'val_top5_acc': 0.36000001430511475}"
     ]
    }
   ],
   "source": [
    "validation_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PySpark",
   "language": "",
   "name": "pysparkkernel"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "python",
    "version": 2
   },
   "mimetype": "text/x-python",
   "name": "pyspark",
   "pygments_lexer": "python2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}